Enhanced the <xmlpeek> task to support more advanced
XPath functions and syntax. It is now possible to use
functions such as count() and to index the node using XPath
directly.
(feature request #1560566).
Catch UnauthorizedAccessException in PathScanner to prevent
NAnt from crashing when using the Scan() function to search
for file(s) in directory with special permissions.
When the "zipfile" attribute specifies a non-existent path,
the base directory(ies) will be created.
(bug #2981389).
0.90-alpha1 (April 1, 2010)
Breaking changes
Core
Extensibility
Deprecated NAnt.Core.Element.InitializeElement(XmlNode) and
NAnt.Core.Task.InitializeTask(XmlNode) in favor of
NAnt.Core.Element.Initialize(). This was done to discourage direct access to
the XML node that was used to initialize the construct.
For patterns specified using <includesfile>
or <excludesfile>, lines that have a number sign (#) as the first non-blank
character in a line are now ignored.
If "MailLogger.smtp.username", "MailLogger.smtp.port"
or "MailLogger.smtp.enablessl" are set, messages must be delivered
using the SMTP protocol over the network. [.NET 1.1 or higher]
In Cygwin, the directory
containing the Mono configuration files was not correctly
constructed from pkg-config info, leading to errors when
running applications that use System.Configuration.
If the embedded resource compiler for the target framework does
not support assembly references, then copy both the compiler
and related files (based on pattern matching) to the
intermediary compile directory
(bug #1591991).
Since NAnt 0.84, task authors have been able to specify the
location of the command-line tool by applying a ProgramLocationAttribute to
classes deriving from ExternalProgramBase.
The ProgramLocationAttribute allows task authors
to specify whether the tool is located in the framework directory
(eg. C:\WINDOWS\Microsoft.NET\Framework\v1.1.4432) or the
SDK directory (eg. C:\Program Files\Microsoft Visual Studio .NET 2003\SDK\v1.1)
without actually having to deal with the complexity of knowing
the actual path to these directories (for each supported framework).
In NAnt 0.86, we've taken this one step further. Each defined
framework now has a (ordered) list of directories that can be
scanned to locate a framework tool. The list of directories
can be easily tuned for each framework by modifying the
<tool-paths>
nodes in the NAnt configuration file.
An example of such a node for the Mono 3.5 profile:
The directories configured in the <tool-paths>
node of the current target framework will be scanned in the
order in which they are defined.
The tool paths are implicitly used when a given tool cannot
be located on the location specified by the ProgramLocationAttribute.
As such, this only applies to tasks deriving from ExternalProgramBase.
To expose this functionality to build authors, we've added a
framework::get-tool-path
function that can be used to search for a given tool.
Introduced support for forcing a managed application to run
on the currently targeted CLR.
This was previously only possible by modifying the <startup>
section of the application configuration file or by using
constructs specific to each CLR (eg. using COMPLUS_VERSION
environment variable for the MS CLR), which made build scripts
non-portable.
Developers extending NAnt, can now control this by setting the
Managed property for tasks deriving from
ExternalProgramBase.
For build authors, forcing a managed application to run on a
specific version of a CLR can be done by setting the
"managed" attribute of <exec>
to strict.
Added "autoref" attribute to enable automatically
referencing of assemblies if they have the same name as an
imported namespace or as a type annotation when declaring a
variable.
Added "nostdlib" attribute which instructs the
compiler not to import standard library.
Added "versionsafe" attribute which causes the
compiler to generate errors for implicit method overrides.
Runtime callable wrapper is not used when generating Windows
Forms control for ActiveX component that has no Primary
Interop Assembly.
When importing a type library, [out, retval] parameters of
methods on dispatch-only interfaces (dispinterfaces) are
not transformed into return values (bug #1527210).
Dependencies are not handled properly for Enterprise Template
projects in Visual Studio .NET 2003 solutions (bug #1534864).
Added "nostdlib" attribute which can be used to
instruct the compiler not to reference standard libraries
(system.dll and VBC.RSP). [.NET 2.0 or higher]
0.85-rc 4 (June 2, 2006)
Framework support
Added support for .NET Framework 2.0 (except for <solution> task).
Logic for determining whether compilation is necessary is not correct when PCH
file is specified (bug
#1191185).
All sources are compiled if any of the specified sources is not up-to-date (bug
#1191285).
Macro definitions specified using the <defines> collection
are passed to the compiler, regardless of the value of the "if" and
"unless" attributes (bug
#1221945).
Modification of an external file does not trigger a rebuilt of the resource
(bug
#1195320).
Macro definitions specified using the <defines> collection
are passed to the compiler, regardless of the value of the "if" and
"unless" attributes (bug
#1221945).
Added "MailLogger.success.attachments" and
"MailLogger.failure.attachments" properties to allow a set of files
to be attached to the message that is sent.
Define types in task containers.
Global types can now be (re)defined in task containers
(such a <if> ,
<foreach>).
If "flatten" is set to true and multiple source files are
selected to be copied / moved to the same destination file, only the source
file that was last written to should actually be copied / moved (bug
#1165252).
Added "MailLogger.body.encoding" property to allow the encoding of
the body of the message to be set.
Response File
NAnt now supports the use of a response file. Passing @<file> on the
command line will cause the contents of <file> to be read as part of the
command line. Multiple @<file> arguments may be used.
[FileSetBuildElement("fileset")]
public FileSet CopyFileSet {
get { return _fileset; }
set { _fileset = value; }
}
0.85-rc 2 (February 12, 2005)
General changes
Building NAnt
The source distribution of NAnt no longer contains pre-built binaries to build
a full version of NAnt. Instead, we now include GNU Make and NMake make files
to build a bootstrap version of NAnt, which is then used to build the full
version of NAnt. More information is available
here.
License
The special exception that is part of the NAnt license has been modified to
avoid confusion.
Bug fixes
Core
XML Schema
NAnt XML Schema definition for collection based elements was incorrect (bug
#1076620).
Manifest resource names of resources in J# projects do not match those
generated by Microsoft Visual Studio.NET.
For embedded resources that are dependent on a source file, namespace prefixing
is wrong when a namespace declaration is not present in the source file (bug
#1077253).
Users should be warned about possible issues with resx files when building a
project for a down-level target framework (bug
#1077254).
"App.config" should not be considered an output file for Class Library
projects.
Win32 resources in Visual C++ projects are not compiled (bug
#1077712).
Improve error reporting when a referenced component cannot be resolved (bug
#1079777).
MFC and ATL shared linking is not supported for Visual C++ projects (bug
#1078636).
<solution> task
doesn't support COM, OCX apps built in Visual C++ (bug
#1078641).
Support for some compile and link arguments is missing (bug
#1080237).
Project dependencies are not re-evaluated when assembly reference is converted
to project reference (bug
#1076015).
Resolution of assembly references does not match Visual Studio .NET (bug
#1077869).
Relative URI specified as argument for document() function is not
considered to be relative to the base URI of stylesheet containing the function
call (bug
#1078896).
Added "usesourcepath" attribute to allow the source file's directory to be used
as current directory for resolving relative file paths. [.NET 2.0 or higher]
The "name" attribute of the
<import> element has been deprecated, and replaced by
a "namespace" attribute. This change affects the following tasks:
<asminfo>, <script>
and <vbc>.
0.85-rc 1 (November 28, 2004)
Framework support
NAnt 0.85 adds support for the following frameworks (both as runtime and as
target framework):
Mono (both 1.0 and 2.0 profile)
.NET 2.0 Beta 1
By default, NAnt will now target the framework on which its running. For
example, if NAnt is running on .NET 2.0, the assemblies built using the
<csc> task will target .NET 2.0. Previous versions of
NAnt would target .NET 1.0 by default.
Information on how to override the target framework, can be found
here.
Breaking changes
In previous version of NAnt, the <arg>
element (used by, for example, the <exec>
task) would automatically add quotes for both "file" and "value" attributes in
the command line generated by the task. That automatic quoting has been removed
for "value" attributes (but not for "file" attributes). This change may break
build files that assume that both arguments specified using the "file" and
"value" attributes will automatically be quoted.
Overwriting of read-only properties in tasks other than the
<property> task will now result in a build failure. Previous
versions of NAnt would silently ignore an update of a read-only property.
The <nunit2> task been
updated to support
NUnit 2.2. Assemblies built using previous versions of NUnit should
either be rebuilt using
NUnit 2.2 or a
binding redirect should be configured in the application configuration
file of the test assembly.
General changes
Improved error reporting when invalid values are specified for attibutes
representing files or directories.
This release of NAnt introduces support for expressions. More information is
available here.
Lots of built-in properties have been deprecated, and replaced by functions.
More information is available here.
NAnt will now report unknown attributes and child elements when initializing
build elements.
Commandline changes
Added "-e[macs]" option, which can be used to produce logging information
without adornments.
Added "-ext[ension]" option to allow loading of external assemblies. As a
result, third party loggers or listeners no longer have to reside in the NAnt
bin directory or the GAC in order to be used by NAnt.
Deprecated -[defaultframewor]k option in favor of -t[argetframework].
The <nunit> task has
been deprecated, and will be moved to NAntContrib
in a future release. NUnit 1.0 test assemblies will remain supported through
NAntContrib, but we strongly advise you to upgrade to NUnit 2.x.
If no explicit application configuration file is specified, a configuration
file matching the name of the test assembly with extension ".config" will be
used for the test domain.
WebMaps are now case-insensitive (and added attribute to enable
case-sensitivity).
Added "enablewebdav" attribute to allow WebDAV access for web projects.
Added a few unit tests to reduce the likelyhood of regressions.
Fixed some minor issues with regards to Visual C++ support.
General performance has been improved, except for project with loads of
resources.
Added support for exclusion of source files for Visual C++ projects.
No longer stop loading projects, when the first excluded project is encountered
(bug #982685).
No longer automatically use Primary Interop Assemblies for references to type
libraries, but output warning instead.
Added support for satellite assemblies.
Respect project build order set in VS.NET.
VB.NET specific settings are now processed.
Improved support for precompiled headers, better grouping of files that should
be compiled in one go.
Added support for empty projects.
No longer attempt to build ignored projects.
Match behaviour of VS.NET when resolving assembly references.
Fixed lookup of type libraries in the registry.
Expansion of macros is now case-insensitive.
Zero-byte resx files are now skipped to match VS.NET.
Introduced support for nmake projects.
Added support for web projects nested in Enterprise Template Projects.
Compiled resource file are now stored in the obj\<configuration>
directory relative to project directory. The compiled resource files will not
be removed when the task finishes, by doing this resource files will now only
be recompiled if the compiled resource file in the object directory is no
longer up-to-date. This matches the behaviour of VS.NET.
Added support for deploying App.config to output directory.
If "failonerror" is false, the
<sysinfo> task will output a warning message in the build log
when a certain environment variable cannot be exposed as a property (because
of, for example, more strict naming rules for properties) and continue
processing other environment variables. In previous versions of NAnt, execution
of the <sysinfo> task
would halt on the first error.
The Task.LogPrefix property has been deprecated. Messages that are
written to build log by a given task, will now automatically get prefixed with
the task name. This behaviour can be disabled by the new -e[macs] commandline
option.
0.84 (December 26, 2003)
Task changes
<xmlpeek>
Fixed issues with logging statements.
Added unit tests.
<xmlpoke>
Added unit tests.
0.84-rc 2 (December 21, 2003)
General changes
Specifying multiple targets on the command line will no longer cause all
dependencies of these targets to be executed again.
The XmlLogger
will now correctly handle null-characters in the build output.
Fixed issue with resources specified using the <resources> element
of the compiler tasks.
Task changes
<solution>
Fixed issues with web-projects.
Added support for generating strongly signed ActiveX/COM wrapper assemblies.
<xmlpeek>
filename attribute was renamed to file to improve
consistency with other tasks.
<xmlpoke>
filename attribute was renamed to file to improve
consistency with other tasks.
0.84-rc 1 (December 6, 2003)
Breaking changes
Some existing build scripts may stop working now or in the next release due to
the following changes:
The NAntContrib binaries are no longer included in the NAnt distribution
package. The NAntContrib distribution package can now be obtained
here.
The <call> task now executes the given target and all its
dependencies. In previous versions of NAnt only the target itself would be
executed.
The todir attribute of the <copy> and <move>
tasks no longer defaults to the project base directory. It must now be set
explicitly.
The force attribute of the <call> task has been
deprecated and has no longer any effect. The <call> task
will now always execute the specified target, regardless of the fact that this
target has already been executed before.
The string-based files and attachments attributes of
the <mail> task have been replaced by fileset support.
In previous versions of NAnt, the documentation stated that a target identified
by the nant.onfailure property would be executed when the build
fails. However, NAnt actually executed a target identified by the nant.failure
property (if available). This has now been corrected and the old syntax (nant.failure)
is now deprecated.
The <param> element of the <style> task
has been deprecated in favor of a <parameters> collection
with nested <parameter> elements. The <parameter>
element now also supports a namespaceuri, if and unless
attribute. See the documentation of the <style> task for
more information.
In previous versions of NAnt, the Plain formatter was implicitly
added in the <nunit2> task. In NAnt 0.8.4, the Plain
formatter will only implicitly be added if no other formatters are specified.
In this case, a warning message will be output to the build log encouraging
build authors to explicitly add this formatter for forward compatibility. In
future versions of NAnt, the Plain formatter will no longer
implicitly be added.
The nested <param> child element of the <style>
task has been deprecated in favor of a nested <parameters> collection.
General changes
The user documentation has been overhauled. Nested elements are more clearly
documented, documentation has been added for element types such as filesets and
credentials, and the overall format is slightly cleaner and easier to use.
Improved bootstrapping NAnt on linux. Now supports Mono 0.28.
Localization support has been improved in the <csc>, <jsc>,
<vbc> and <vjc> tasks: when dynamixprefix
is set to "true" and prefix is set to the root namespace of the assembly for
the nested <resources> element, the compiler tasks will now
compile resources with IDs matching these generated by VS.NET. Support for the
generation of satellite assemblies was also added to these tasks.
On systems with both the .NET Framework 1.0 and .NET Framework 1.1 installed,
NAnt will now execute on the .NET Framework 1.1 by default. Note, the default
target framework has remained unchanged, and is still .NET Framework 1.0.
New Tasks
<asminfo>
Moved from NAntContrib to
NAnt, and was rewritten to support multiple code languages and attribute types.
<servicecontroller>
Allows a Windows service to be controlled (started, stopped, ...).
<delay-sign>
Supports delay-signing of strongly named assemblies.
<mc>,<rc> and <midl>
Moved from NAntContrib to
NAnt. These tasks control compilation of service messages, resources, and IDL
code respectively.
<xmlpeek>
Extracts text from an XML file at the location specified by an XPath
expression.
<xmlpoke>
Replaces text in an XML file at the location specified by an XPath expression.
Task changes
<call>
The <call> task now executes the given target and all its
dependencies. In previous versions of NAnt only the target itself would be
executed.
The force attribute of the <call> task has been
deprecated and has no longer any effect. The <call> task
will now always execute the specified target, regardless of the fact that this
target has already been executed before.
<cl>
Added support for Managed Extensions.
<copy>
The todir attribute no longer defaults to the project base
directory. It must now be set explicitly.
Added flatten attribute to allow all matching files to be
copied to a single directory.
<csc>
Improved localization support.
Added support for additional search directories to resolve assembly references
through a nested <lib> element.
<cvs-checkout>
Added option to checkout a revision based on sticky tag, -r on the command line
client.
Added option to checkout a module to an alternate directory, -d on the command
line client.
Fixed bug in parsing cvsnt date format.
<cvs-update>
Fixed bug in parsing cvsnt date format.
<echo>
Added level attribute to allow messages to be output with a
specific level.
<fail>
Allow reason of failure to be specified as inline content.
<get>
The httpproxy attribute of the <get> task is
deprecated, use the new <proxy> child element instead.
Added <credentials> child element used for authenticating
the request with the Internet resource.
Deprecated the ignoreerrors attribute in favor of the failonerror
attribute.
Added timeout attribute to allow length of time to wait for a
response or the request to timeout to be specified.
<if>
Added <uptodatefiles child element for uptodate fileset
support.
<if uptodatefile="..."> now behaves as documented, meaning
that nested tasks will only be executed if the file specifies in the
uptodatefile attribute actually exists and the file specified in the uptodatefile
attribute is more recent or the same lastwritetime than the file(s) specifies
in the comparefile attribute and <comparefiles>
fileset.
<include>
A verbose message will now be output to the build log when a file is included
multiple times. In previous versions of NAnt, this would cause a build failure.
<jsc>
Improved localization support.
Added support for additional search directories to resolve assembly references
through a nested <lib> element.
<mail>
The string-based files and attachments attributes
have been replaced by fileset support.
<move>
The todir attribute no longer defaults to the project base
directory. It must now be set explicitly.
Added flatten attribute to allow all matching files to
be moved to a single directory.
<nant>
Properties can now be added or overridden when calling a nested build using the
new <properties> child element.
buildfile is now a required attribute, which makes it harder to
accidently write an infinitely looping build.
<nantschema>
Currently the <nantschema> task does not generate the
correct XML Schema definition for collections and arrays. This tasks needs to
be updated. Please use with caution.
<ndoc>
Updated the <ndoc> task to using version 1.2 of NDoc.
<nunit2>
Updated the <nunit2> task to use version 2.1 of NUnit.
In previous versions of NAnt, the Plain formatter was implicitly
added. In NAnt 0.8.4, the Plain formatter will only implicitly be
added if no other formatters are specified. In this case, a warning message
will be output to the build log encouraging build authors to explicitly add
this formatter for forward compatibility. In future versions of NAnt, the Plain
formatter will no longer implicitly be added.
Added outputdir attribute for <formatter> element
to control the directory where the test result file will be stored (if the usefile
attribute is "true").
<property>
Added overwrite attribute to the <property> task
to control whether the value of the specified property should be overwritten
when the property already exists.
Added support for dynamic properties, meaning properties of which references to
other properties are not expanded when the value is set.
<resgen>
Added support for specifying a prefix to <resgen> task when
using a fileset.
<solution>
Added nested <assemblyfolders> fileset element that allows a
set of folders to be set, that should be searched to resolve assembly
references.
By default, the Visual Studio.NET assembly folders will be searched to resolve
assembly references. An includevsfolders attribute was added to
control whether these folders should be searched for assembly references.
Added <excludeprojects> fileset that allows a set of
projects to be excluded.
An outputdir attribute can now be specified, which overrides the
directory where compiled targets will be placed.
A nested <webmap> element was added that maps URL's of web
projects to local path, thereby removing the need to configure the web server
to allow access to these project files.
Added support for Visual C++ projects.
A large number of defect fixes and performance improvements have been applied.
<style>
The nested <param> child element has been deprecated in
favor of a nested <parameters> collection.
<touch>
If the file specified in the single-file case does not exist, it will now be
created.
<vbc>
Improved localization support.
Added support for additional search directories to resolve assembly references
through a nested <lib> element.
<vjc>
Improved localization support.
Added support for additional search directories to resolve assembly references
through a nested <lib> element.
<zip>
Fixed issue when files were included that were not located beneath the basedir
of the fileset.
Added includeemptydirs attribute to control whether empty
directories should be included in the generated zip file.
Fixed failure when no basedir for fileset was specified.
Fixed failure when basedir of fileset is set to the root directory
of a drive in Windows.
API changes
Added ProgramLocationAttribute that can be assigned to a task to
indicate that it wraps an executable that is part of either the .NET Framework
or the .NET Framework SDK, and have NAnt figure out the full path to the
executable using the framework settings in the NAnt configuration file.
FileSetAttribute has been deprecated. The BuildElementAttribute
should be used instead.
Added FrameworkConfigurableAttribute that can be assigned to a
task attribute to allow the default values of that attribute to be configured
from the framework configuration section in the NAnt configuration file for the
currently active framework.
Added <proxy> and <credentials> data
types that are used to provide proxy settings and authentication information
for tasks that connect to external resources (eg. the <get> task).
Added support for framework-specific third party libraries.
Included NAntContrib binaries are from a release build. In rc3 they were debug
versions.
0.8.3-rc3 (August 29, 2003)
User-visible changes
Added test directory to distribution fixing the build failure in 0.8.3.
0.8.3-rc2 (July 28, 2003)
User-visible changes
Built with .NET 1.0.
This release candidate is built with version 1.0 of the .NET Framework. The
binaries for RC1 had been built with version 1.1, which had backwards
compatibility issues.
Fixed defect: temp directory leak in <solution> task.
Matthew Mastracci fixed a major temp directory leak. It was leaking approx. one
temp directory per project! You should clear your Local Settings\Temp directory
for the user you use to build your solutions.
<solution> VB.NET support.
The <solution> task now supports VB.NET projects. This was meant to be
part of the RC1 release.
Matthew Mastracci has also checked in support for reading resources of VB
projects and generating the appropriate dependent resource name.
Documentation for NAntContrib.
This release candidate includes the binaries and documentation for the
NAntContrib extensions. Note that the source is still distributed seperately
during this release cycle.
0.8.3-rc1 (July 10, 2003)
User-visible changes
NAntContrib is now distributed with NAnt.
To better support the frequently-used NAntContrib extensions, the library is
now distributed as part of the NAnt release.
Preliminary Linux support.
This is the first release with Linux support, so please report any issues you
encounter. The next release will be fully tested and documented on both Linux
and Windows.
New Tasks.
<cvs-checkout> task : Checkout source from CVS.
<cvs-update:> task : Update source from CVS.
<solution> task : compile .sln directly. In most cases, this means you no
longer have to preprocess a solution with the slingshot tool. Supports both
Visual Studio .NET and Visual Studio 2003.
Changed tasks.
See the section below for details.
FileSet references.
You can now define a named FileSet and refer to it anywhere a FileSet is used.
API changes
Namespace changes
"SourceForge" is no longer part of the NAnt namespaces.
Split classes up into Tasks and Types.
Task assemblies now have their own namespaces.
Removed Msft prefix from base classes.
Logging framework changed
Refactored NAnt (build) logging system : moved to an event driven logging
system, and allow thresholds to be set. The build outcome is now completely
handled by the loggers.
Replaced the LogListener with an IBuildLogger interface for loggers and an
IBuildListener interface for build listeners.
The ConsoleLogger is replaced by a DefaultLogger, which always logs to the
console, and which can also be configured to log to a file (using the -logfile
option).
The static Log class is removed and replaced by instance methods on the Project
and Task classes. These instance methods actually fire events that get handled
by the build logger and buid listeners.
Added a Level enum that is used to assign a priority (level) to a message. This
allows messages to be filtered on their priority.
Added a strongly typed collection for the build listeners.
Updated all existing logging statements to use the new logging system instead
of the static Log class. Assigned levels to the existing logging statements.
Added MailLogger that can be used to send the build results as an email, see
xml docs for how its to be configured.
Many, many style/structure/documentation fixes. More that are worth listing
here.
Fixed NUnit2 support for FileSets.
Prevent warnings for using obsolete methods to allow NDoc Documenter.Nant to
build on .NET 1.1 runtime.
Nightly.xml no longer depends on NAntContrib tasks.
Moved <mail> task and test back into core as its working fine on Linux
now.
New attribute-driven command-line parser.
Command-line client changes
Changed target back to the default argument.
Moved company information (http://nant.sourceforge.net) from help text to logo
banner.
Added support for running default.build if there are multiple build files in a
directory.
Added support for collection-based command-line options, with the following
restrictions :
property type should implement ICollection
collection should have an Add method with one parameter
parameter of the Add method should be strongly-typed
collection should have a default public constructor
the property should have a setter if the collection is not initialized (null
reference)
Fixed "bug" where ApplicationException would no longer be throw when no
matching buildfile is found after searching the directory tree upwards.
Updated short form of buildfile to -f.
Added -q shortname for -quiet command-line option.
Changed description of -indent command-line option.
Added command-line option for adding build listeners.
Updated xml documentation.
Added command-line options for filtering build output (-debug and -quiet).
Jarek's patch to allow setting of the default framework from the command line,
fixes bug 729778.
Always use identifier mono-1.0 for Mono framework, no use in always creating
new framework configurations for every Mono release.
Task changes
<exec>
Added support for an environment optionset to the <exec> task.
Fixed optionset so that it correctly returns optionvalues.
Remove Timeout from ExecTask, make Timeout in ExternalProgramBase a task
attribute and make it writable.
Throw BuildException if process has not exited after timeout.
<vjc>
Added attribute for setting the warninglevel (0-4).
Added attribute for specifiying list of warnings that should be suppressed by
the compiler.
<jsc>
Added support for codepage compiler flag.
Added attribute for setting the warninglevel (0-4).
<csc>
Added support for codepage compiler flag.
Renamed optionoptimize attribute to optimize.
Added attribute for setting the warninglevel (0-4).
Added attribute for specifiying list of warnings that should be suppressed by
the compiler.
Patch from Justin Santa Barbara to add optimize flag to csc.
Fixed csc example.
<nantschema>
Added makefile for building on Linux. Also a new bin directory for Linux
specific binaries.
<mcs>
Removed <mcs> task. the <csc> task in combination with the
framework support should be used instead.
<nant>
Fixed problem with basedir in nested <nant> build being incorrect if
basedir="." is used.
Have new project inherit the default framework from the current project.
<copy>
Fix for <copy> task breakage on Linux.
Reenabled File.SetAttributes on Mono build as bug #41999 has been fixed.
<if>
Fixed logging bug with parenthesis instead of brace. Caused <if
uptodate...> to fail erroneously.
<cl> and <link>
On demand compile support for <link> and <cl> tasks.
Added unit tests for the <cl> and <link> tasks.
Moved Visual C++ related tasks into Win32Assemblies so it doesn't get built in
a Mono/Linux build.
<fileset>
Added support for FileSet references. Framework for making all types
referencable but only implemented for FileSets right now.
<mail>
Reenabled usage of StringWriter constructor with CultureInfo as this bug in
Mono is fixed.
No longer have empty strings as default.
Bcc and cc are no longer set to an empty string when not specified in
buildfile, thereby preventing problems with Mono bug #45746.
0.8.2 (April 24, 2003)
Misc bugfixes.
0.8.2-rc3 (April 17, 2003)
<if> task changes to support the uptodate test.
Changes for task item element initialization.
Read output of <exec>'d (and other external program) processes and insert
into logfile.
Fixed logging for <regex> task.
Made NAnt errors less chatty.
NAnt now works without Framework SDK installed.
Fixed bugs in <Copy> and <Move> tasks which caused exceptions when
using todir and a FileSet, in certain cases.
New <unzip> task.
New <loadtasks> task which replaces the functionality of taskdef (from
NAntContrib).
<foreach> supports <in><items> FileSet to work on files.
0.8.2-rc2 (April 12, 2003)
Fix for <nunit2> task using FileSet.
Fix for FileSet's <includeList> element.
0.8.2-rc1 (April 12, 2003)
Logging cleanups: use log4net for internal logging.
FxCop cleanups for correctness.
Support for multiple versions of .NET framework.
Changes to make NAnt more Mono-friendly.
Updated SharpZipLib library.
Makes error reporting more accurate - give line numbers for property expansion
errors.
Multiple test assembly support for <nunit2> task.
General speed-up for directory/file scanning.
<resgen> task file generation correctness fixes.
Added support multiple delimiters and string trimming to LoopTask's file line
mode.
More support for csc/vbc command-line options.
0.8.1 (February 21, 2003)
Added more command-line options (-f: to specify a buildfile).
Added case sensitivity checks.
Added <vjc> task.
Fixed NUnit2 support.
Misc bugfixes and cleanups from contributors.
0.7.9 (June 11, 2002)
If more than one build file matches the criteria, e.g. two files ending in
.build than NAnt will report an error.
Added -find option, causes NAnt to search up the directory tree looking for the
buildfile. Use in conjunction with -buildfile:foo.* to find the first foo.*
file up the directory tree.
Added -projecthelp option, callable targets should now include a description
attribute to describe briefly what they do.
CompilerBase tasks now check for changed resources and recompiles if out of
date.
Compiler tasks reportq what caused the rebuild when verbose is on, try 'NAnt
-verbose'.
Improved Log class.
Added PlainText NUnit formatter, see NAnt's build file for an example.
nant.onsuccess and nant.onfailure properties can now name a target to get
executed at the end of a build.
FileSets now have an absolute element. Items inside an absolute element will
always be included in the file set. This is useful for references that are in
the system path. See the HelloWindowsForms build file for an example.
-set option changed to -D to be more like Ant.
Unknown command line arguments cause program help to be displayed.
FileSets now support absolute paths and parent directories.
*Tasks.dll assemblies that are in the same folder as NAnt are automatically
loaded and scanned for tasks.
User manual available.
Help for tasks is auto-generated.
<attrib> task added.
<gac> task added and moved to NAntContrib project.
<sysinfo> task added.
Added failonerror, verbose, if and unless attributes to all tasks.
DESIGN DECISION: all elements and attributes will be lowercase
Major reworking of FileSet class (removed absolutes element, added asis
attribute).
Tasks/Targets/FileSet includes/excludes now have if/unless attributes.
New Unit Tests added.
CallTest.cs
DeleteTest.cs
EchoTest.cs
FailTest.cs
MkdirTest.cs
MoveTest.cs
PropertyTest.cs
New Properties added during project initilization.
nant.location points to nant.exe directory
nant.tasks.[TaskName].location points to [TaskName] host assembly
<nant> task now inherits properties to new project.
Tasks moved to NAntContrib Project
GacTask.cs
RcTask.cs
ResGenTask.cs
TlbExpTask.cs
TlbImpTask.cs
TypedCollectionTask.cs
Vb6Task.cs
NUnit XML format updated.
Many, many, many bugs fixed.
0.7.749 (January 19, 2002)
<docnet> task added, try 'NAnt doc' to build NAnt's documentation.
NUnitCore.dll added to project.
Fixed FileSet basedir attributes, they now expand macros.
<script> task and example added - thanks to Sergey Chaban.
Build file now extracts version number from AssemblyInfo.cs - thanks to Sergey
Chaban.
CompilerBase now adds quotations to all referenced files - thanks to Mike
Krueger.
BuildException is now serializable.
ExternalProgramBase reports differentiates between Process exceptions and
program return codes now.
Unit tests are now run as part of the buid process.
Changed verions number to 0.5 to reflect the number of changes in the code
base.
0.1.5 (July 22, 2001)
Only compiles program if source file last write time > output last write
time.
Refactored compiler code into common CompilerBase class.
Refactored compiler and exec task into common ExternalProgramBase class.
Added <arg value="/win32res:filename"/> element to all external program
tasks.
Added Int32ValidatorAttribute and BooleanValidatorAttribute classes to perform
error checking on task attributes after macro expansion but before task
execution. Search for BooleanValidator or Int32Validator in tasks for examples.
Changed Task attribute names to TaskAttributeAttribute and FileSetAttribute.
Removed default value for task attributes (set with initial value).
Changes to Project class on how to initialize a project and run it.
Right aligned task prefixes to clean up output.
Added or enhanced these tasks
vbc, jsc, csc
move
nant
tstamp
exec (failonerror attribute)
0.1.4 (July 19, 2001)
Added or enhanced these tasks
echo
fail
property
copy (respects basedir)
delete (respects basedir)
mkdir (respects basedir)
exec
0.1.3 (July 18, 2001)
Dependencies working via depends attribute on targets.
Changed name from NBuild to NAnt.
Using the name "Parameter" to refer to the xml attributes in tasks because it
was conflicting badly with .NET Attributes.
Added FileSetParameterAttribute so that FileSet parameters would autoinit.
Renamed TaskAttributeAttribute to StringParameterAttribute.
Broke into seperate source files (one per class).
Changed default build file from Project.xml to the first file with a .build
extension.
0.1.2 (July 16, 2001)
Basic functionality to have NAnt build itself (<csc> task).
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place, Suite 330, Boston, MA 02111-1307 USA
As a special exception, the copyright holders of this software give you
permission to link the assemblies with independent modules to produce
new assemblies, regardless of the license terms of these independent
modules, and to copy and distribute the resulting assemblies under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from or
based on these assemblies. If you modify this software, you may extend
this exception to your version of the software, but you are not
obligated to do so. If you do not wish to do so, delete this exception
statement from your version.
A copy of the GNU General Public License is available in the COPYING.txt file
included with all NAnt distributions.
NAnt ships with a prebuilt version of NDoc.
The NAnt license does not apply to these components located in the bin folder
of the distribution. NDoc is licensed under the
GNU General Public License.
NUnit License
NAnt ships with a prebuilt version of NUnit.
The NAnt license does not apply to these components located in the bin folder
of the distribution. NUnit is licensed under a
OSI approved license.
A 3 digit octal string, specify the user, group and other modes in the standard Unix fashion. Only applies to directories. The default is 755.
False
filemode
int
A 3 digit octal string, specify the user, group and other modes in the standard Unix fashion. Only applies to plain files. The default is 644.
False
gid
int
The group identifier (GID) for the tar entry.
False
groupname
string
The groupname for the tar entry.
False
prefix
string
The top level directory prefix. If set, all file and directory paths in the fileset will have this value prepended. Can either be a single directory name or a "/" separated path.
False
uid
int
The user identifier (UID) for the tar entry.
False
username
string
The username for the tar entry.
False
basedir
directory
The base of the directory of this fileset. The default is the project base directory.
False
casesensitive
bool
Indicates whether include and exclude patterns must be treated in a case-sensitive way. The default is true on Unix; otherwise, false.
False
defaultexcludes
bool
Indicates whether default excludes should be used or not. The default is true.
False
failonempty
bool
When set to true, causes the fileset element to throw a ValidationException when no files match the includes and excludes criteria. The default is false.
False
id
string
The ID used to be referenced later.
False
refid
string
The ID to use as the reference.
False
Nested Elements:
<includes>
Deprecated. The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</includes>
<include>
The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</include>
<excludes>
Deprecated. The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</excludes>
<exclude>
The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</exclude>
<includesList>
Deprecated. The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesList>
<includesfile>
The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesfile>
<excludesfile>
The files from which a list of patterns or files to exclude should be obtained.
Parameters
Attribute
Type
Description
Required
name
file
The name of a file; each line of this file is taken to be a pattern.
True
if
bool
If true then the patterns will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be excluded; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
Provides credentials for password-based authentication schemes.
Parameters
Attribute
Type
Description
Required
domain
string
The domain or computer name that verifies the credentials.
False
if
bool
Indicates if the credentials should be used to provide authentication information to the external resource. If true then the credentials will be passed; otherwise, not. The default is true.
False
password
string
The password for the user name associated with the credentials.
False
unless
bool
Indicates if the credentials should not be used to provide authentication information to the external resource. If false then the credentials will be passed; otherwise, not. The default is false.
False
username
string
The user name associated with the credentials.
False
id
string
The ID used to be referenced later.
False
refid
string
The ID to use as the reference.
False
Requirements
Assembly: NAnt.Core (0.92.4526.0)
nant-0.92-rc1/doc/help/types/index.html 0000644 0001750 0001750 00000013203 11757307413 017666 0 ustar jtaylor jtaylor
Data Type Reference
Filesets are groups of files. These files can be found in a directory tree starting in a base directory and are matched by patterns taken from a number of patterns. Filesets can appear inside tasks that support this feature or at the project level, i.e., as children of <project>.
Paths are groups of files and/or directories that need to be passed as a single unit. The order in which parts of the path are specified in the build file is retained, and duplicate parts are automatically suppressed.
[This is preliminary documentation and subject to change.]
Contains HTTP proxy settings used to process requests to Internet resources.
Parameters
Attribute
Type
Description
Required
host
string
The name of the proxy host.
True
port
int
The port number on host to use.
True
bypassonlocal
bool
Specifies whether to bypass the proxy server for local addresses. The default is false.
False
if
bool
Indicates if the proxy should be used to connect to the external resource. If true then the proxy will be used; otherwise, not. The default is true.
False
unless
bool
Indicates if the proxy should not be used to connect to the external resource. If false then the proxy will be used; otherwise, not. The default is false.
[This is preliminary documentation and subject to change.]
Specialized <fileset> class for managing assembly files.
If an include pattern does not contain any wildcard characters then the assembly will be searched for in following locations (in the order listed):
The base directory of the fileset.
The directories specified using the nested <lib> element.
The list of reference assemblies of the current target framework.
The reference assemblies of a given target framework are defined using <reference-assemblies> filesets in the <framework> node of the NAnt configuration file.
Parameters
Attribute
Type
Description
Required
basedir
directory
The base of the directory of this fileset. The default is the project base directory.
False
casesensitive
bool
Indicates whether include and exclude patterns must be treated in a case-sensitive way. The default is true on Unix; otherwise, false.
False
defaultexcludes
bool
Indicates whether default excludes should be used or not. The default is true.
False
failonempty
bool
When set to true, causes the fileset element to throw a ValidationException when no files match the includes and excludes criteria. The default is false.
False
id
string
The ID used to be referenced later.
False
refid
string
The ID to use as the reference.
False
Nested Elements:
<lib>
Additional directories to search in for assembly references.
A specialized <fileset> used for setting the lib directories.
The primary reason for this class is to allow the BaseDirectory to always be the same value as the parent <assemblyfileset>
Parameters
Attribute
Type
Description
Required
casesensitive
bool
Indicates whether include and exclude patterns must be treated in a case-sensitive way. The default is true on Unix; otherwise, false.
False
defaultexcludes
bool
Indicates whether default excludes should be used or not. The default is true.
False
failonempty
bool
When set to true, causes the fileset element to throw a ValidationException when no files match the includes and excludes criteria. The default is false.
False
id
string
The ID used to be referenced later.
False
refid
string
The ID to use as the reference.
False
Nested Elements:
<includes>
Deprecated. The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</includes>
<include>
The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</include>
<excludes>
Deprecated. The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</excludes>
<exclude>
The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</exclude>
<includesList>
Deprecated. The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesList>
<includesfile>
The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesfile>
<excludesfile>
The files from which a list of patterns or files to exclude should be obtained.
Parameters
Attribute
Type
Description
Required
name
file
The name of a file; each line of this file is taken to be a pattern.
True
if
bool
If true then the patterns will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be excluded; otherwise, skipped. The default is false.
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</includes>
<include>
The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</include>
<excludes>
Deprecated. The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</excludes>
<exclude>
The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</exclude>
<includesList>
Deprecated. The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesList>
<includesfile>
The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesfile>
<excludesfile>
The files from which a list of patterns or files to exclude should be obtained.
Parameters
Attribute
Type
Description
Required
name
file
The name of a file; each line of this file is taken to be a pattern.
True
if
bool
If true then the patterns will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be excluded; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
Controls the behaviour of a compiler with regards to the reporting of warnings.
Parameters
Attribute
Type
Description
Required
id
string
The ID used to be referenced later.
False
refid
string
The ID to use as the reference.
False
Nested Elements:
<include>
Specifies a list of warnings that the compiler should treat as errors. This overrides the warnaserror attribute. Only supported when targeting .NET 2.0 or higher.
Represents a compiler warning.
Parameters
Attribute
Type
Description
Required
number
string
A warning number, or comma-separated list of warnings, that you want the compiler to suppress or report.
True
if
bool
If true then the element will be processed; otherwise, skipped. The default is true.
False
unless
bool
If true then the element will be skipped; otherwise, processed. The default is false.
False
</include>
<exclude>
Specifies a list of warnings that the compiler should NOT treat as errors. This is only useful if warnaserror is true. Only supported when targeting .NET 2.0 or higher.
Represents a compiler warning.
Parameters
Attribute
Type
Description
Required
number
string
A warning number, or comma-separated list of warnings, that you want the compiler to suppress or report.
True
if
bool
If true then the element will be processed; otherwise, skipped. The default is true.
False
unless
bool
If true then the element will be skipped; otherwise, processed. The default is false.
False
</exclude>
Examples
Instruct a compiler to report warning 0519 as an error.
Indicates whether the entires in the .cvsignore should be used to limit the file list; true to exclude files in .cvsignore, otherwise false. The default is true.
False
basedir
directory
The base of the directory of this fileset. The default is the project base directory.
False
casesensitive
bool
Indicates whether include and exclude patterns must be treated in a case-sensitive way. The default is true on Unix; otherwise, false.
False
defaultexcludes
bool
Indicates whether default excludes should be used or not. The default is true.
False
failonempty
bool
When set to true, causes the fileset element to throw a ValidationException when no files match the includes and excludes criteria. The default is false.
False
id
string
The ID used to be referenced later.
False
refid
string
The ID to use as the reference.
False
Nested Elements:
<includes>
Deprecated. The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</includes>
<include>
The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</include>
<excludes>
Deprecated. The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</excludes>
<exclude>
The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</exclude>
<includesList>
Deprecated. The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesList>
<includesfile>
The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesfile>
<excludesfile>
The files from which a list of patterns or files to exclude should be obtained.
Parameters
Attribute
Type
Description
Required
name
file
The name of a file; each line of this file is taken to be a pattern.
True
if
bool
If true then the patterns will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be excluded; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
Specialized <fileset> class for managing resource files.
Parameters
Attribute
Type
Description
Required
dynamicprefix
bool
Indicates whether prefixes should be dynamically generated by taking the path of the resource relative to the basedir and appending it to the specified prefix. The default is false.
False
prefix
string
Indicates the prefix to prepend to the actual resource. This is usually the default namspace of the assembly.
False
basedir
directory
The base of the directory of this fileset. The default is the project base directory.
False
casesensitive
bool
Indicates whether include and exclude patterns must be treated in a case-sensitive way. The default is true on Unix; otherwise, false.
False
defaultexcludes
bool
Indicates whether default excludes should be used or not. The default is true.
False
failonempty
bool
When set to true, causes the fileset element to throw a ValidationException when no files match the includes and excludes criteria. The default is false.
False
id
string
The ID used to be referenced later.
False
refid
string
The ID to use as the reference.
False
Nested Elements:
<includes>
Deprecated. The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</includes>
<include>
The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</include>
<excludes>
Deprecated. The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</excludes>
<exclude>
The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</exclude>
<includesList>
Deprecated. The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesList>
<includesfile>
The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesfile>
<excludesfile>
The files from which a list of patterns or files to exclude should be obtained.
Parameters
Attribute
Type
Description
Required
name
file
The name of a file; each line of this file is taken to be a pattern.
True
if
bool
If true then the patterns will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be excluded; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
A set of patterns, mostly used to include or exclude certain files.
The individual patterns support if and unless attributes to specify that the element should only be used if or unless a given condition is met.
The includesfile and excludesfile elements load patterns from a file. When the file is a relative path, it will be resolved relative to the project base directory in which the patternset is defined. Each line of this file is taken to be a pattern.
The number sign (#) as the first non-blank character in a line denotes that all text following it is a comment:
EventLog.cs
# requires Mono.Posix
SysLogEventLogImpl.cs
# uses the win32 eventlog API
Win32EventLogImpl.cs
Patterns can be grouped to sets, and later be referenced by their id.
When used as a standalone element (global type), any properties that are referenced will be resolved when the definition is processed, not when it actually used. Passing a reference to a nested build file will not cause the properties to be re-evaluated.
To improve reuse of globally defined patternsets, avoid referencing any properties altogether.
Parameters
Attribute
Type
Description
Required
id
string
The ID used to be referenced later.
False
refid
string
The ID to use as the reference.
False
Nested Elements:
<include>
Defines a single pattern for files to include.
Parameters
Attribute
Type
Description
Required
name
string
The name pattern to include/exclude.
True
if
bool
If true then the pattern will be used; otherwise, skipped. The default is true.
False
unless
bool
If false then the pattern will be used; otherwise, skipped. The default is false.
False
</include>
<includesfile>
Loads multiple patterns of files to include from a given file, set using the name parameter.
Parameters
Attribute
Type
Description
Required
name
string
The name pattern to include/exclude.
True
if
bool
If true then the pattern will be used; otherwise, skipped. The default is true.
False
unless
bool
If false then the pattern will be used; otherwise, skipped. The default is false.
False
</includesfile>
<exclude>
Defines a single pattern for files to exclude.
Parameters
Attribute
Type
Description
Required
name
string
The name pattern to include/exclude.
True
if
bool
If true then the pattern will be used; otherwise, skipped. The default is true.
False
unless
bool
If false then the pattern will be used; otherwise, skipped. The default is false.
False
</exclude>
<excludesfile>
Loads multiple patterns of files to exclude from a given file, set using the name parameter.
Parameters
Attribute
Type
Description
Required
name
string
The name pattern to include/exclude.
True
if
bool
If true then the pattern will be used; otherwise, skipped. The default is true.
False
unless
bool
If false then the pattern will be used; otherwise, skipped. The default is false.
Define two sets. One holding C# sources, and one holding VB sources. Both sets only include test sources when the test property is set. A third set combines both C# and VB sources.
Defines a patternset with patterns that are loaded from an external file, and shows the behavior when that patternset is passed as a reference to a nested build script.
External file "c:\foo\build\service.lst" holding patterns of source files to include for the Foo.Service assembly:
AssemblyInfo.cs
*Channel.cs
ServiceFactory.cs
Main build script located in "c:\foo\default.build":
although the patternset is used from the "service" build script, the path to the external file is resolved relative to the base directory of the "main" build script in which the patternset is defined.
the "TraceListener.cs" file is included, even though the "build.debug" property was changed to false after the patternset was defined (but before it was passed to the nested build, and used).
[This is preliminary documentation and subject to change.]
Filesets are groups of files. These files can be found in a directory tree starting in a base directory and are matched by patterns taken from a number of patterns. Filesets can appear inside tasks that support this feature or at the project level, i.e., as children of <project>.
Patterns
As described earlier, patterns are used for the inclusion and exclusion. These patterns look very much like the patterns used in DOS and UNIX:
'*' matches zero or more characters
For example:
*.cs matches .cs, x.cs and FooBar.cs, but not FooBar.xml (does not end with .cs).
'?' matches one character
For example:
?.cs matches x.cs, A.cs, but not .cs or xyz.cs (both don't have one character before .cs).
Combinations of *'s and ?'s are allowed.
Matching is done per-directory. This means that first the first directory in the pattern is matched against the first directory in the path to match. Then the second directory is matched, and so on. For example, when we have the pattern /?abc/*/*.cs and the path /xabc/foobar/test.cs, the first ?abc is matched with xabc, then * is matched with foobar, and finally *.cs is matched with test.cs. They all match, so the path matches the pattern.
To make things a bit more flexible, we added one extra feature, which makes it possible to match multiple directory levels. This can be used to match a complete directory tree, or a file anywhere in the directory tree. To do this, ** must be used as the name of a directory. When ** is used as the name of a directory in the pattern, it matches zero or more directories. For example: /test/** matches all files/directories under /test/, such as /test/x.cs, or /test/foo/bar/xyz.html, but not /xyz.xml.
There is one "shorthand" - if a pattern ends with / or \, then ** is appended. For example, mypackage/test/ is interpreted as if it were mypackage/test/**.
Case-Sensitivity
By default, pattern matching is case-sensitive on Unix and case-insensitive on other platforms. The casesensitive parameter can be used to override this.
Default Excludes
There are a set of definitions that are excluded by default from all tasks that use filesets. They are:
**/.svn
**/.svn/**
**/_svn
**/_svn/**
**/.git
**/.git/**
**/.git* (eg. .gitignore)
**/.hg
**/.hg/**
**/.hg* (eg. .hgignore)
**/SCCS
**/SCCS/**
**/vssver.scc
**/vssver2.scc
**/_vti_cnf/**
**/*~
**/#*#
**/.#*
**/%*%
**/CVS
**/CVS/**
**/.cvsignore
If you do not want these default excludes applied, you may disable them by setting defaultexcludes to false.
Parameters
Attribute
Type
Description
Required
basedir
directory
The base of the directory of this fileset. The default is the project base directory.
False
casesensitive
bool
Indicates whether include and exclude patterns must be treated in a case-sensitive way. The default is true on Unix; otherwise, false.
False
defaultexcludes
bool
Indicates whether default excludes should be used or not. The default is true.
False
failonempty
bool
When set to true, causes the fileset element to throw a ValidationException when no files match the includes and excludes criteria. The default is false.
False
id
string
The ID used to be referenced later.
False
refid
string
The ID to use as the reference.
False
Nested Elements:
<includes>
Deprecated. The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</includes>
<include>
The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</include>
<excludes>
Deprecated. The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</excludes>
<exclude>
The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</exclude>
<includesList>
Deprecated. The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesList>
<includesfile>
The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesfile>
<excludesfile>
The files from which a list of patterns or files to exclude should be obtained.
Parameters
Attribute
Type
Description
Required
name
file
The name of a file; each line of this file is taken to be a pattern.
True
if
bool
If true then the patterns will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be excluded; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
Paths are groups of files and/or directories that need to be passed as a single unit. The order in which parts of the path are specified in the build file is retained, and duplicate parts are automatically suppressed.
Defines a path element to add to the current path.
Represents a nested path element.
Parameters
Attribute
Type
Description
Required
dir
directory
The name of a directory to add to the path. Will be replaced with the absolute path of the directory.
False
file
file
The name of a file to add to the path. Will be replaced with the absolute path of the file.
False
if
bool
If true then the entry will be added to the path; otherwise, skipped. The default is true.
False
path
<path>
A string that will be treated as a path-like string. You can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Opposite of if. If false then the entry will be added to the path; otherwise, skipped. The default is false.
False
</pathelement>
Examples
Define a global <path> that can be referenced by other tasks or types.
The top level directory prefix. If set, all file and directory paths in the fileset will have this value prepended. Can either be a single directory name or a "/" separated path.
False
basedir
directory
The base of the directory of this fileset. The default is the project base directory.
False
casesensitive
bool
Indicates whether include and exclude patterns must be treated in a case-sensitive way. The default is true on Unix; otherwise, false.
False
defaultexcludes
bool
Indicates whether default excludes should be used or not. The default is true.
False
failonempty
bool
When set to true, causes the fileset element to throw a ValidationException when no files match the includes and excludes criteria. The default is false.
False
id
string
The ID used to be referenced later.
False
refid
string
The ID to use as the reference.
False
Nested Elements:
<includes>
Deprecated. The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</includes>
<include>
The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</include>
<excludes>
Deprecated. The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</excludes>
<exclude>
The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</exclude>
<includesList>
Deprecated. The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesList>
<includesfile>
The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesfile>
<excludesfile>
The files from which a list of patterns or files to exclude should be obtained.
Parameters
Attribute
Type
Description
Required
name
file
The name of a file; each line of this file is taken to be a pattern.
True
if
bool
If true then the patterns will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be excluded; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
Represent a chain of NAnt filters that can be applied to a Task.
A FilterChain represents a collection of one or more filters that can be appled to a Task such as the <copy> task. In the case of the <copy> task, the contents of the copied files are filtered through each filter specified in the filter chain. Filtering occurs in the order the filters are specified with filtered output of one filter feeding into another.
[This is preliminary documentation and subject to change.]
A specialized <fileset> used for specifying a set of directories.
Hint for supporting tasks that the included directories instead of files should be used.
Parameters
Attribute
Type
Description
Required
basedir
directory
The base of the directory of this fileset. The default is the project base directory.
False
casesensitive
bool
Indicates whether include and exclude patterns must be treated in a case-sensitive way. The default is true on Unix; otherwise, false.
False
defaultexcludes
bool
Indicates whether default excludes should be used or not. The default is true.
False
failonempty
bool
When set to true, causes the fileset element to throw a ValidationException when no files match the includes and excludes criteria. The default is false.
False
id
string
The ID used to be referenced later.
False
refid
string
The ID to use as the reference.
False
Nested Elements:
<includes>
Deprecated. The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</includes>
<include>
The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</include>
<excludes>
Deprecated. The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</excludes>
<exclude>
The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</exclude>
<includesList>
Deprecated. The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesList>
<includesfile>
The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesfile>
<excludesfile>
The files from which a list of patterns or files to exclude should be obtained.
Parameters
Attribute
Type
Description
Required
name
file
The name of a file; each line of this file is taken to be a pattern.
True
if
bool
If true then the patterns will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be excluded; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
Replaces all occurrences of a given string in the original input with user-supplied replacement string.
This filter replaces all occurrences of a given string in the original input stream with a user-supplied replacement string. By default string comparisons are case sensitive but this can be changed by setting the optional ignorecase attribute to true.
To use this filter specify the string to be replaced with the from attribute and the string to replace it with using the to attribute.
Filters are intended to be used as a element of a <filterchain>.
Parameters
Attribute
Type
Description
Required
from
string
The string to be replaced.
True
ignorecase
bool
Determines if case will be ignored. The default is false.
False
to
string
The new value for the replaced string. Am empty string is permissible.
False
if
bool
If true then the filter will be used; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the filter will be executed; otherwise, skipped. The default is false.
False
Examples
Replace all occurrences of "3.14" with "PI".
<replacestring from="3.14" to="PI" />
Replace all occurrences of "string", "String", etc. with "System.String".
[This is preliminary documentation and subject to change.]
Replaces tokens in the original input with user-supplied values.
This filter replaces all token surrounded by a beginning and ending token. The default beginning and ending tokens both default to '@'. The optional begintoken and endtoken attributes can be specified to change either token. By default string comparisons are case sensitive but this can be changed by setting the optional ignorecase attribute to true.
Tokens are specified by using the Token element. It is possible to specify from 1 to n tokens and replacement values. Values can be any valid NAnt expression.
Filters are intended to be used as a element of a <filterchain>.
Parameters
Attribute
Type
Description
Required
begintoken
char
Marks the beginning of a token. The default is "@".
False
endtoken
char
Marks the end of a token. The default is "@".
False
ignorecase
bool
Determines if case will be ignored. The default is false.
False
if
bool
If true then the filter will be used; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the filter will be executed; otherwise, skipped. The default is false.
False
Nested Elements:
<token>
Tokens and replacement values.
ReplaceTokens filter token.
Parameters
Attribute
Type
Description
Required
key
string
Token to be replaced.
True
value
string
New value of token.
True
if
bool
Indicates if the token should be used to replace values. If true then the token will be used; otherwise, not. The default is true.
False
unless
bool
Indicates if the token should not be used to replace values. If false then the token will be used; otherwise, not. The default is false.
False
</token>
Examples
Replace all occurrences of the string @DATE@ with the value of property "TODAY".
[This is preliminary documentation and subject to change.]
Represents an environment variable.
Parameters
Attribute
Type
Description
Required
name
string
The name of the environment variable.
True
dir
directory
The value for a directory-based environment variable. NAnt will convert it to an absolute path.
False
file
file
The value for a file-based environment variable. NAnt will convert it to an absolute filename.
False
if
bool
Indicates if the environment variable should be passed to the external program. If true then the environment variable will be passed; otherwise, skipped. The default is true.
False
path
<path>
The value for a PATH like environment variable. You can use : or ; as path separators and NAnt will convert it to the platform's local conventions.
False
unless
bool
Indicates if the environment variable should not be passed to the external program. If false then the environment variable will be passed; otherwise, skipped. The default is false.
Specifies the directory where the output file should be written to, if usefile is true. If not specified, the output file will be written to the directory where the test module is located.
False
usefile
bool
Determines whether output should be persisted to a file. The default is false.
[This is preliminary documentation and subject to change.]
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
The application configuration file to use for the NUnit test domain. If not specified, NAnt will try to use a configuration name matching the file name of the assembly with extension ".config".
False
assemblyname
file
Name of the assembly to search for tests.
False
haltonfailure
bool
Build fails on failure. The default is true.
False
testname
string
Name of a specific testfixture to run. If not specified then all testfixtures are run.
False
transformfile
file
XSLT transform file to use when using the Plain formatter.
[This is preliminary documentation and subject to change.]
Represents an assembly-level attribute.
Parameters
Attribute
Type
Description
Required
type
string
Typename of the assembly-level attribute.
True
asis
bool
If true then the value of the attribute will be set as is, without actually looking for a matching constructor or named properties. The default is false.
False
if
bool
Indicates if the attribute should be generated.
False
unless
bool
Indicates if the attribute should be not generated.
[This is preliminary documentation and subject to change.]
Represents an XSLT parameter.
Parameters
Attribute
Type
Description
Required
name
string
The name of the XSLT parameter.
True
value
string
The value of the XSLT parameter.
True
if
bool
Indicates if the parameter should be added to the XSLT argument list. If true then the parameter will be added; otherwise, skipped. The default is true.
False
namespaceuri
string
The namespace URI to associate with the parameter.
False
unless
bool
Indicates if the parameter should not be added to the XSLT argument list. If false then the parameter will be added; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
A base class for creating tasks for executing CVS client commands on a CVS repository.
Parameters
Attribute
Type
Description
Required
compressionlevel
int
Compression level to use for all net traffic. This should be a value from 1-9.
NOTE: This is not available on sharpcvslib.
False
cvsfullpath
file
The full path to the cvs binary used. The cvs tasks will attempt to "guess" the location of your cvs binary based on your path. If the task is unable to resolve the location, or resolves it incorrectly this can be used to manually specify the path.
False
cvsroot
string
The cvs root variable has the following components:
[protocol]:[username]@[servername]:[server path]
protocol: ext, pserver, ssh (sharpcvslib); if you are not using sharpcvslib consult your cvs documentation.
username: [username]
servername: cvs.sourceforge.net
server path: /cvsroot/nant
False
cvsrsh
file
The executable to use for ssh communication.
False
module
string
The module to perform an operation on.
False
quiet
bool
Indicates if the output from the cvs command should be supressed. The default is false.
False
readonly
bool
true if the sandbox files should be checked out in read only mode. The default is false.
False
readwrite
bool
true if the sandbox files should be checked out in read/write mode. The default is true.
False
reallyquiet
bool
Indicates if the output from the cvs command should be stopped. The default is false.
False
usesharpcvslib
bool
true if the SharpCvsLib binaries that come bundled with NAnt should be used to perform the cvs commands, false otherwise.
You may also specify an override value for all cvs tasks instead of specifying a value for each. To do this set the property sourcecontrol.usesharpcvslib to false.
If you choose not to use SharpCvsLib to checkout from cvs you will need to include a cvs.exe binary in your path.
False
commandline
string
Command-line arguments for the program. The command line arguments are used to specify any cvs command options that are not available as attributes. These are appended after the command itself and are additive to whatever attributes are currently specified.
False
destination
directory
Destination directory for the local sandbox. If destination is not specified then the current directory is used.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
passfile
file
The full path to the cached password file. If not specified then the environment variables are used to try and locate the file.
False
password
string
Deprecated. The password for logging in to the repository.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Represents an XSLT extension object. The object should have a default parameterless constructor and the return value should be one of the four basic XPath data types of number, string, Boolean or node set.
Parameters
Attribute
Type
Description
Required
assembly
file
The assembly which contains the XSLT extension object.
True
typename
string
The full type name of the XSLT extension object.
True
if
bool
Indicates if the extension object should be added to the XSLT argument list. If true then the extension object will be added; otherwise, skipped. The default is true.
False
namespaceuri
string
The namespace URI to associate with the extension object.
False
unless
bool
Indicates if the extension object should not be added to the XSLT argument list. If false then the extension object will be added; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
[This is preliminary documentation and subject to change.]
Parameters
Attribute
Type
Description
Required
pattern
string
The string pattern to use to format the property.
True
property
string
The name of the NAnt property to set.
True
if
bool
Indicates if the formatter should be used to format the timestamp. If true then the formatter will be used; otherwise, skipped. The default is true.
False
unless
bool
Indicates if the formatter should be not used to format the timestamp. If false then the formatter will be used; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
Provides the abstract base class for tasks that execute external applications.
When a ProgramLocationAttribute is applied to the deriving class and exename does not return an absolute path, then the program to execute will first be searched for in the location specified by LocationType.
If the program does not exist in that location, then the list of tool paths of the current target framework will be scanned in the order in which they are defined in the NAnt configuration file.
Parameters
Attribute
Type
Description
Required
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Framework-configurable parameters
Attribute
Type
Description
Required
exename
string
The name of the executable that should be used to launch the external program.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
False
Nested Elements:
<arg>
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Functions as a chainable TextReader
Implements a abstraction over a TextReader that allows the class to represent either a TextReader or another ChainableReader to which it is chained. By passing a ChainableReader as a constructor paramater it is possiable to chain many ChainableReaders together. The last ChainableReader in the chain must be based on a TextReader.
[This is preliminary documentation and subject to change.]
A base class for creating tasks for executing CVS client commands on a CVS repository.
Parameters
Attribute
Type
Description
Required
commandline
string
Command-line arguments for the program. The command line arguments are used to specify any cvs command options that are not available as attributes. These are appended after the command itself and are additive to whatever attributes are currently specified.
False
destination
directory
Destination directory for the local sandbox. If destination is not specified then the current directory is used.
False
passfile
file
The full path to the cached password file. If not specified then the environment variables are used to try and locate the file.
False
password
string
Deprecated. The password for logging in to the repository.
False
ssh
file
The executable to use for ssh communication.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
supportsdelaysign
bool
Indicates whether the compiler for a given target framework supports the "delaysign" option. The default is false.
False
supportskeycontainer
bool
Indicates whether the compiler for a given target framework supports the "keycontainer" option. The default is false.
False
supportskeyfile
bool
Indicates whether the compiler for a given target framework supports the "keyfile" option. The default is false.
False
supportsnowarnlist
bool
Indicates whether the compiler for a given target framework supports a command line option that allows a list of warnings to be suppressed. The default is false.
False
supportspackagereferences
bool
Indicates whether package references are supported by compiler for a given target framework. The default is false.
False
supportswarnaserrorlist
bool
Indicates whether the compiler for a given target framework supports the "warnaserror" option that takes a list of warnings. The default is false.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Represents an XML namespace.
Parameters
Attribute
Type
Description
Required
prefix
string
The prefix to associate with the namespace.
True
uri
string
The associated XML namespace URI.
True
if
bool
Indicates if the namespace should be added to the XmlNamespaceManager. If true then the namespace will be added; otherwise, skipped. The default is true.
False
unless
bool
Indicates if the namespace should not be added to the XmlNamespaceManager. list. If false then the parameter will be added; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
A specialized <fileset> used for setting the lib directories.
The primary reason for this class is to allow the BaseDirectory to always be the same value as the parent <assemblyfileset>
Parameters
Attribute
Type
Description
Required
casesensitive
bool
Indicates whether include and exclude patterns must be treated in a case-sensitive way. The default is true on Unix; otherwise, false.
False
defaultexcludes
bool
Indicates whether default excludes should be used or not. The default is true.
False
failonempty
bool
When set to true, causes the fileset element to throw a ValidationException when no files match the includes and excludes criteria. The default is false.
False
id
string
The ID used to be referenced later.
False
refid
string
The ID to use as the reference.
False
Nested Elements:
<includes>
Deprecated. The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</includes>
<include>
The items to include in the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to include.
True
asis
bool
If true then the file name will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the file will be searched for on the path. The default is false.
False
if
bool
If true then the pattern will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be included; otherwise, skipped. The default is false.
False
</include>
<excludes>
Deprecated. The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</excludes>
<exclude>
The items to exclude from the fileset.
Parameters
Attribute
Type
Description
Required
name
string
The pattern or file name to exclude.
True
if
bool
If true then the pattern will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the pattern will be excluded; otherwise, skipped. The default is false.
False
</exclude>
<includesList>
Deprecated. The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesList>
<includesfile>
The files from which a list of patterns or files to include should be obtained.
Parameters
Attribute
Type
Description
Required
asis
bool
If true then the patterns in the include file will be added to the <fileset> without pattern matching or checking if the file exists. The default is false.
False
frompath
bool
If true then the patterns in the include file will be searched for on the path. The default is false.
False
if
bool
If true then the patterns will be included; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be included; otherwise, skipped. The default is false.
False
name
file
The name of a file; each line of this file is taken to be a pattern.
True
</includesfile>
<excludesfile>
The files from which a list of patterns or files to exclude should be obtained.
Parameters
Attribute
Type
Description
Required
name
file
The name of a file; each line of this file is taken to be a pattern.
True
if
bool
If true then the patterns will be excluded; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the patterns will be excluded; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
Represents a nested path element.
Parameters
Attribute
Type
Description
Required
dir
directory
The name of a directory to add to the path. Will be replaced with the absolute path of the directory.
False
file
file
The name of a file to add to the path. Will be replaced with the absolute path of the file.
False
if
bool
If true then the entry will be added to the path; otherwise, skipped. The default is true.
False
path
<path>
A string that will be treated as a path-like string. You can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Opposite of if. If false then the entry will be added to the path; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
A set of environment variables.
Nested Elements:
<option>
Deprecated. Environment variable to pass to a program.
Represents an option.
Parameters
Attribute
Type
Description
Required
name
string
Name of the option.
True
if
bool
Indicates if the option should be passed to the task. If true then the option will be passed; otherwise, skipped. The default is true.
False
unless
bool
Indicates if the option should not be passed to the task. If false then the option will be passed; otherwise, skipped. The default is false.
False
value
string
Value of the option. The default is a null reference (Nothing in Visual Basic).
False
</option>
<variable>
Environment variable to pass to a program.
Represents an environment variable.
Parameters
Attribute
Type
Description
Required
name
string
The name of the environment variable.
True
dir
directory
The value for a directory-based environment variable. NAnt will convert it to an absolute path.
False
file
file
The value for a file-based environment variable. NAnt will convert it to an absolute filename.
False
if
bool
Indicates if the environment variable should be passed to the external program. If true then the environment variable will be passed; otherwise, skipped. The default is true.
False
path
<path>
The value for a PATH like environment variable. You can use : or ; as path separators and NAnt will convert it to the platform's local conventions.
False
unless
bool
Indicates if the environment variable should not be passed to the external program. If false then the environment variable will be passed; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
Specifies the execution mode for managed applications.
For backward compatibility, the following string values can also be used in build files:
Value
Corresponding field
"true"
Auto
"false"
Default
Even if set to Default, the operating system can still run the program as a managed application.
On Linux this can be done through binfmt_misc, while on Windows installing the .NET Framework redistributable caused managed applications to run on the MS CLR by default.
Fields
Field
Description
Auto
Leave it up to the CLR to determine which specific version of the CLR will be used to run the application.
Default
Do not threat the program as a managed application.
Strict
Forces an application to run against the currently targeted version of a given CLR.
[This is preliminary documentation and subject to change.]
NAnt is available in either a source or binary distribution. The binary
distribution is all you need to use NAnt to build your projects, including
creating your own custom tasks, types and functions.
If you are upgrading NAnt from a previous version, you must never install over
the top of your previous installation. Delete or rename the existing
installation directory before installing the new version of NAnt.
Installing from binaries
Download the binary distribution archive. Either nant-bin.zip or
nant-bin.tar.gz will work, the contents of each archive are the
same.
Remove any previous versions of NAnt you may have installed.
Extract the contents of the archive to the location you wish to install NAnt
(eg: C:\Program Files\NAnt in windows, or /usr/local/nant in Linux)
Depending on your environment, create a wrapper script to run NAnt:
Run NAnt using Microsoft.NET
Create a file called nant.bat in a directory that is included in
the PATH system environment variable. (eg. C:\WINDOWS).
Add the following to nant.bat:
@echo off
"C:\Program Files\NAnt\bin\NAnt.exe" %*
Run NAnt using Mono
Windows
Create a file called nant.bat in a directory that is included in
the PATH system environment variable. (eg. C:\WINDOWS).
Add the following to nant.bat:
@echo off
mono "C:\Program Files\NAnt\bin\NAnt.exe" %*
Linux / Cygwin
Create a file called nant in a suitable location in your
filesystem (eg. /usr/local/bin).
[This is preliminary documentation and subject to change.]
NAnt is different. Instead of a model where it is extended with shell-based commands, NAnt is extended using task classes. Instead of writing shell commands, the configuration files are XML-based, calling out a target tree where various tasks get executed. Each task is run by an object that implements a particular Task interface.
Granted, this removes some of the expressive power that is inherent in being able to construct a shell command such as 'find . -name foo -exec rm {}', but it gives you the ability to be cross-platform - to work anywhere and everywhere. And hey, if you really need to execute a shell command, NAnt has an <exec> task that allows different commands to be executed based on the OS it is executing on.
For more information on why Ant and NAnt were developed read the Ant Introduction.
[This is preliminary documentation and subject to change.]
The idea for NAnt came from Hazware's XBuild project which in turn was inspired from Apache Ant. After emailing the author for a beta 2 release of the tool and getting no response Gerry Shaw ported the code to .NET beta 2. Due to the number of changes from .NET beta 1 to beta 2 the result was a total rewrite.
NAnt was registered at Source Forge on July 18, 2001 with the first public release made that day.
The name NAnt comes from the fact that this tool is Not Ant.
[This is preliminary documentation and subject to change.]
To use NAnt you need one of the following CLR's:
Microsoft .NET Framework 1.0
Microsoft .NET Framework 1.1
Microsoft .NET Framework 2.0
Mono 1.x
Note: Additional requirements may apply to individual tasks.
Library Dependencies
NAnt uses a number of open source third party libaries. Recent versions are included included with the NAnt distribution and no extra work is required to install them. More information on these libraries are available at:
A task can have multiple attributes (or arguments, if you prefer). The
value of an attribute may contain references to a property.
These references will be resolved before the task is executed.
Extensions can be devided in the following categories:
Tasks
Filters
Functions
Global Types
NAnt currently provides two mechanisms to make third-party extensions available for use in build scripts:
Automatic discovery
Forced scan
Both mechanisms use .NET reflection to scan one or more assemblies for the presence of extensions. When found,
these extensions are registered in the NAnt type system, and from then on these are available for all build
scripts (in the current NAnt instance).
2.1 Automatic discovery
To facilitate registration of extensions that are used in multiple (or even all) build
scripts, NAnt supports automatic discovery of extensions.
In this context, automatic discovery means scanning a predefined set of directories and files for extensions.
The actual set of directories and files that is scanned is determined by:
Operating system
Runtime framework
Project
2.1.1 Operating system
When starting NAnt, all assemblies matching the following patterns will be scanned for extensions:
Windows
Pattern
Action
Description
*Tasks.dll
include
NAnt Core assemblies
*Tests.dll
include
NAnt test assemblies
extensions/common/neutral/**/*.dll
include
Framework and version-neutral assemblies
NAnt.MSNetTasks.dll
exclude
Microsoft.NET specific assembly
NAnt.MSNet.Tests.dll
exclude
Microsoft.NET specific test assembly
Unix
Pattern
Action
Description
*Tasks.dll
include
NAnt Core assemblies
*Tests.dll
include
NAnt test assemblies
extensions/common/neutral/**/*.dll
include
Framework and version-neutral assemblies
NAnt.MSNetTasks.dll
exclude
Microsoft.NET specific assembly
NAnt.MSNet.Tests.dll
exclude
Microsoft.NET specific test assembly
NAnt.Win32Tasks.dll
exclude
Win32 specific assembly
NAnt.Win32.Tests.dll
exclude
Win32 specific test assembly
NOTE: all patterns are matched relative to the NAnt base directory, which is the directory in which NAnt.exe is located.
2.1.2 Runtime framework
Depending on the runtime framework on which NAnt is running, some additional directories are scanned.
In general, the following include patterns are applied:
Whenever a build project is started, NAnt will scan the following directories for assemblies that match the *.dll pattern:
<Project Base Directory>/extensions/common/neutral/
<Project Base Directory>/extensions/common/<CLR version>/
<Project Base Directory>/extensions/<framework family>/neutral/
<Project Base Directory>/tasks/<framework family>/<framework version>/
Example:
For a project file located in "c:\projects\log4net" with NAnt running on the Microsoft .NET 2.0 runtime, NAnt would end-up scanning the following project-level directories:
c:\projects\log4net\extensions\common\neutral\
c:\projects\log4net\extensions\common\2.0\
c:\projects\log4net\extensions\net\neutral\
c:\projects\log4net\extensions\net\2.0\
2.2 Forced scan
To explicitly instruct NAnt to scan a certain assembly (or set of assemblies) for extensions, build authors can use the <loadtasks> tasks.
In this example there are two targets, "clean" and "build". By default the
"build" target will be called.
Examples
You can find the files you need to try out these examples in the examples
folder that comes with the NAnt distribution.
nant
Runs NAnt and builds the project in debug mode (the default).
nant clean
Runs NAnt and removes the compiled files if they exist.
nant -D:debug=false
Runs NAnt and builds the project in non-debug mode. Even though the build
file sets the debug property to true, the value that is set on the command line
will not be touched, as the "overwrite" attribute on the
<property>
task is set to "false".
Important: Some tasks like the compiler tasks will only execute
if the date stamp of the generated file is older than the source files.
If you compile HelloWorld project in debug mode and then try to compile it
again in non-debug mode without first cleaning nothing will happen because NAnt
will think the project does not need rebuilding.
[This is preliminary documentation and subject to change.]
A target has these attributes:
Attribute
Description
Required
name
The name of the target.
Yes
depends
A comma-separated list of names of targets on which this target depends.
No
if
An expression that should evaluate to true in order for this target to
execute.
No
unless
An expression that, when evaluated to true, will cause the target to be
skipped.
No
description
A short description of this target's function.
No
The optional description attribute can be used to provide a
one-line description of this target, which is printed by the
-projecthelp command-line option.
Dependencies
A target can depend on other targets. You might have a target for
compiling, for example, and a target for creating a distributable. You
can only build a distributable when you have compiled first, so the distribute
target depends on the compile target. NAnt resolves these
dependencies.
NAnt tries to execute the targets in the depends attribute in the
order they appear from left to right. It is possible that a target can
get executed earlier when an earlier target depends on it:
Suppose we want to execute target D. From its depends attribute,
you might think that first target C, then B and then A is executed.
Wrong! C depends on B, and B depends on A, so first A is executed, then
B, then C, and finally D.
A target gets executed only once, even when more than one target depends on it
(see the previous example). However, when the <call>
task is used to execute a target, both the target and all its dependent targets
will be re-executed.
Wild Targets
A target can be marked as wild by setting the name attribute
to "*". A build file can contain up to one wild target, and it is executed if
and only if the invoked target does not exist in the current build file. Wild
targets let you define how to handle invalid requests, or provide generic
behavior for unknown targets. For example:
The last target is executed if the invoked target is neither A nor B.
Conditional Execution
A target also has the ability to perform its execution if or unless a property
has been set. This allows, for example, better control on the building
process depending on the state of the system (OS, command-line property
defines, etc.). To make a target sense this property, you should
add the if or unless attribute with an expression
that the target should react to. For example:
[This is preliminary documentation and subject to change.]
A project has these attributes:
Attribute
Description
Required
name
The name of the project.
No
default
The default target to execute when no target is supplied on the command-line.
No
basedir
The base directory from which all path calculations are done. If not set, the parent directory of the buildfile will be used.
No
Optionally, a description for the project can be provided as a top-level <description>
element. The text contained in the description element is used when the -projecthelp command line option is used. See the
example build file for details.
Each project defines zero or more targets.
A target is a set of tasks to be
executed. When starting NAnt, you can select which target(s) you want to
have executed. When no target is given, the project's default target is used.
When no target and no default target are specified, only the global tasks of the
project are executed.
[This is preliminary documentation and subject to change.]
NAnt provides a rich set of bulitin functions, that allow you to:
manipulate strings
manipulate date/time values
manipulate path names
read the properties of files/directories
access current build information and more
and more
For a full list of supported functions, click here.
Function Call Syntax
To call functions, use prefix::function-name(argument1, ..., argumentN)
syntax within expressions. NAnt will (implicitly) try to convert the arguments
you pass to functions to correct types and will report an error in case of
failure.
For example, assuming you would like to call string::contains('0123456789',1)
which expects two string parameters, but you want to pass the
second parameter which is an integer. NAnt would attempt to convert the second
parameter from int to string, which succeeds and
function is called as if it was written as string::contains('0123456789','1').
The following table shows the possible type conversions:
From Type
To Type
Allowed
Remarks
int
string
Yes
The conversion is always possible.
int
double
Yes
The conversion is always possible.
int
boolean
No
Can be done with the if() conditional operator or simply as (value
<> 0)
int
datetime
No
You cannot convert from int to datetime.
int
timespan
No
You can use the timespan::from-xxx functions to construct a timespan from a given number of days, months, ....
string
int
Yes
If the string doesn't represent an integer value, an error is reported.
string
double
Yes
If the string doesn't represent a floating point value, an error is reported.
string
boolean
Yes
If the string isn't either true or false (case
insensitive), an error is reported.
string
datetime
Yes
If the string doesn't represent a valid date/time, an error is reported.
Date/time string format is MM/DD/YYYY HH:MI:SS
string
timespan
No
You can use timespan::parse to construct a timespan
from a time indicated by a given string. If the string doesn't represent a valid
timespan, an error is reported.
double
int
Yes
If the string doesn't represent an integer value, an error is reported.
double
string
Yes
The converted string uses dot as a fractional part separator so the result
looks like 0.1234567
double
boolean
No
You cannot convert from double to boolean.
double
datetime
No
You cannot convert from double to datetime.
double
timespan
No
You can use the timespan::from-xxx functions to construct a timespan from a given number of days, months, ....
boolean
int
No
You cannot convert from boolean to int. You may
want to use if(boolvalue,1,0) instead.
boolean
string
Yes
The result is 'True' or 'False' string.
boolean
double
No
You cannot convert from boolean to double.
boolean
datetime
No
You cannot convert from boolean to datetime.
boolean
timespan
No
You cannot convert from boolean to timespan.
datetime
int
No
You cannot convert from datetime to int.
datetime
string
Yes
The result is a datetime string with the following format: MM/DD/YYYY HH:MI:SS
datetime
double
No
You cannot convert from datetime to double.
datetime
boolean
No
You cannot convert from datetime to boolean.
datetime
timespan
No
You can use the value of datetime::get-ticks to construct a timespan using timespan::from-ticks.
timespan
int
No
You cannot convert from timespan to int.
timespan
double
No
You can use timespan::get-ticks to convert from timespan to double.
timespan
boolean
No
You cannot convert from timespan to boolean.
timespan
string
No
You can use timespan::to-string to obtain the string representation of a timespan.
timespan
datetime
No
You cannot convert from timespan to datetime.
Custom Functions
Just as you can extend NAnt with your own tasks it is also possible to
implement your own functions for use in build files.
Functions can be implemented in any .NET language and are loaded in the same
manner as tasks. ie either by locating your custom function assembly in the
NAnt bin directory or using the <loadtasks>
task. Example C# code for a Hello World function :
Define a custom function using C#.
[FunctionSet("hello", "Hello")]
public class HelloFunctions : FunctionSetBase {
public HelloFunctions(Project project, PropertyDictionary properties) : base(project, properties) {
}
[Function("hello-world")]
public static string HelloWorldfunc() {
return "Hello World!!";
}
}
and call that function from a build file.
<echo message="${hello::hello-world()}" />
A quick and easy way to develop new functions is to use the
<script> task. This allows you to create and test new functions
without the overhead of building an external assembly. The
<script> task documentation contains examples of custom function
definitions.
The MailLogger captures all output logged through DefaultLogger (standard NAnt
output) and will send success and failure messages to unique e-mail lists, with
control for turning off success or failure messages individually.
Properties controlling the operation of MailLogger are:
Property
Description
Required
MailLogger.mailhost
The SMTP server to use.
No, default is "localhost"
MailLogger.from
The address of the e-mail sender.
Yes, if mail needs to be sent.
MailLogger.failure.notify
Send build failure e-mails ?
No, default is "true".
MailLogger.success.notify
Send build success e-mails ?
No, default is "true".
MailLogger.failure.to
The address to send build failure messages to.
Yes, if failure mail is to be sent.
MailLogger.success.to
The address to send build success messages to.
Yes, if success mail is to be sent.
MailLogger.failure.subject
The subject of build failure messages.
No, default is "Build Failure".
MailLogger.success.subject
The subject of build success messages.
No, default is "Build Success".
MailLogger.failure.attachments
The ID of a fileset representing a set of files to attach when the build fails.
No.
MailLogger.success.attachments
The ID of a fileset representing a set of files to attach when the build is successful.
No.
MailLogger.body.encoding
The encoding type of the body of the e-mail message.
No, default is system's ANSI code page.
MailLogger.smtp.username1
The name of the user to login to the SMTP server.
No.
MailLogger.smtp.password1
The password of the specified user.
No.
MailLogger.smtp.enablessl1
Specifies whether to use SSL to encrypt the connection.
No, default is "false".
MailLogger.smtp.port1
The SMTP server port to connect to.
No, default is "25".
1 Only available when NAnt is built targeting .NET Framework 1.1 (or equivalent) or higher.
Usage:
NAnt.exe -logger:NAnt.Core.MailLogger
Example:
<projectname="MailLogger Test"default="build"><propertyname="MailLogger.mailhost"value="smtp.wherever.be" /><propertyname="MailLogger.from"value="me@telenet.be" /><propertyname="MailLogger.failure.notify"value="true" /><propertyname="MailLogger.success.notify"value="true" /><propertyname="MailLogger.failure.to"value="support@home.be" /><propertyname="MailLogger.success.to"value="support@home.be" /><propertyname="MailLogger.failure.subject"value="Nightly build failure !" /><propertyname="MailLogger.success.subject"value="Nightly build successful" /><propertyname="MailLogger.failure.attachments"value="MailLogger.failure.files" /><propertyname="MailLogger.success.attachments"value="MailLogger.success.files" /><!-- set of files to attach when build fails --><filesetid="MailLogger.failure.files"><includename="dump.log" /><includename="trace.txt" /></fileset><!-- set of files to attach when build is successful --><filesetid="MailLogger.success.files"><includename="trace.txt" /></fileset><targetname="build"><echomessage="Starting build" />
....
<echomessage="Finished build" /></target></project>
XmlLogger
Writes all build information out to an XML file named log.xml, or
the value of the XmlLogger.file property if present, when used as
a listener. When used as a logger, it writes all output to either the console
or to the value of -logfile.
Whether used as a listener or logger, the output is not generated until the
build is complete.
<buildresultsproject="test"><messagelevel="Info"><![CDATA[Buildfile: file:///D:/nant-test/xmlpeek/default.build]]></message><messagelevel="Info"><![CDATA[Target framework: Microsoft .NET Framework 1.1]]></message><messagelevel="Info"><![CDATA[Target(s) specified: build]]></message><targetname="build"><taskname="xmlpeek"><messagelevel="Info"><![CDATA[Peeking at 'D:\nant-test\xmlpeek\input.xml' with XPath expression 'x:parameters/x:param'.]]></message><messagelevel="Info"><![CDATA[Found '1' nodes with the XPath expression 'x:parameters/x:param'.]]></message><duration>15.625</duration></task><duration>15.625</duration></target><duration>31.25</duration></buildresults>
[This is preliminary documentation and subject to change.]
Running NAnt is simple once you have it
installed, just type NAnt. Type
NAnt -help to get usage information.
Specifying the Build File
When nothing is specified, NAnt looks for a file ending with .build,
e.g., NAnt.build, in the current directory. If found, it
uses that file as the build file. If more than one file is found you need
to specify the build file using the -buildfile option (see below).
If you use the -find option, NAnt will search for a build file in
the parent directory, and so on, until the root of the file system has been
reached. To make NAnt use another build file, use the command-line option
-buildfile:file, where file is the build file you want to
use.
Specifying Targets
You can specify one or more targets that should be executed. When omitted, the
target that is specified in the default attribute of the <project>
tag is used.
The -projecthelp option prints out the description of the project,
if it exists, followed by a list of the project's targets. First those with a
description, then those without one.
Setting Properties
To override properties specified in the build file use the
-D:property=value option, where property is the
name of the property, and value is the value for that property.
Examples
NAnt
Runs NAnt using the file ending in *.build.xml file in the
current directory, on the default target.
NAnt -buildfile:..\ProjectName.build
Runs NAnt using the ProjectName.build file in the parent
directory, on the default target.
NAnt clean
Runs NAnt using the default build file in the current directory, on a target
called clean.
NAnt -D:debug=false clean dist
Runs NAnt using the default build file in the current directory, first on
the clean target and then on the dist target
while setting the debug property to false. This
could, for example, make a release distribution from scratch.
Expressions are simple, yet powerful mechanism that allows you to write advanced
formulas to be used in task arguments and conditions that direct the build
process. Expressions can access project properties
and call builtin or user-defined functions.
NAnt provides a rich set of bulitin functions, that allow you to:
manipulate strings
manipulate date/time values
manipulate path names
read the properties of files/directories
access current build information and more
and more
For a full list of supported functions, click here.
2 Expression Syntax
Expressions can be used in all task arguments, by using ${...} notation.
You may use standard syntax for arithmetical (addition, subtraction,
multiplication, division, modulus), logical (negation, conjunction,
alternative) and relational operators (equality, inequality). To call
functions, use prefix::function-name(argument1, ..., argumentN) syntax.
To access properties, you simply use their names without any prefix or suffix.
See the examples section below for more information.
NOTE: Expressions are often used in XML attributes. The grammar specified in this
section applies to the attribute value after XML 1.0 normalization. So, for
example, if the grammar uses the character <, this must not
appear in the XML source as < but must be quoted according to
XML 1.0 rules by, for example, entering it as <.
Examples:
Accessing a property:
<property name="build.version" value="3" /> <echo message="The current date is:
${build.version}" />
This will output the current value of build.version property.
Calling a function
<echo message="The current date is:
${datetime::now()}"
/>
This will output the current date and time.
Storing the result of an expression
To store the result of an expression in a property, use the <property>
task:
<if test="${not file::exists(filename) or file::get-length(filename) = 0}">
<echo message="The version file
${filename}
doesn't exist or is empty!" />
</if>
This will check for the existence of a file version.txt
in a directory specified by myprj.basedir. Note that this makes use of the
short-circuit evaluation supported by NAnt, so you can test for the existence
of the file and check its length in the same expression. ( ie like C, NAnt will
not evaluate the second part of an 'or' expression if the first evaluates to
true )
Using expressions to conditionally execute tasks
All tasks support if and unless attributes.
Expressions can be used there to control which tasks get executed:
This will rebuild the C# library only if it was last rebuilt more than an hour
ago.
3 Data types
Expressions can access, pass and return values of the following types:
Type
Allowed values
int
32-bit signed integer value
long
64-bit signed integer value
double
64-bit signed double precision floating point value
boolean
true or false
string
strings of characters of any length.
datetime
values represeting date & time (range is from 00:00:00, January 1, 1 AD to
23:59:59, December 31, 9999 AD)
timespan
represents a time interval.
version
represents a version number consisting of two to four components.
In addition, the expression evaluation engine allows you to return and pass
values of any CLI type through the use of custom
functions. Note that there's no support for implicit type conversions.
4 Operators
4.1 Operator precedence
NAnt expressions support standard ( c style ) operator precedence, that we're
accustomed to:
and is evaluated before or, left to right. For
example false or true and true and false evaluates as false or
((true and true) and false)
multiplication,division and modulus are evaluated before addition and
subtraction, left to right. For example 1 + 2 * 3 / 4 evaluates as
1 + ((2 * 3) / 4)
parentheses can be used to override the default operator precedence. For
example (1 + 2) * 3 evaluates as written, even though the
multiplication has precedence over addition
NOTE: Because NAnt supports properties whose names can contain dashes,
there's a possible ambiguity between the subtraction of two properties and
accessing a single property with a name containing a dash:
aaa-bbb - this is ambiguous. It could either be property aaa
MINUS property bbb or property aaa-bbb.
To avoid confusion, it's recommended to surround the subtraction operator (or
even better, all binary operators) with spaces. The expression aaa - bbb
always evaluates as a subtraction.
4.2 Operators on Numeric Values
The following operators are supported on numeric values:
+ operator
- operator
* operator
/ operator
% operator
== operator
!= operator
> operator
>= operator
< operator
<= operator
unary plus
unary minus (negation)
4.2.1 Add
Summary
Returns the arithmetic sum of its operands.
Operands
Left Operand
Right Operand
Example
int
int
1 + 5 evaluates to 6
int
long
1 + 6666666667 evaluates to 6666666668
int
double
1 + 5.0 evaluates to 6.0
long
long
6666666667 + 11111111111 evaluates to 17777777778
long
int
6666666667 + 1 evaluates to 6666666668
long
double
6666666667 + 1.5 evaluates to 6666666668.5
double
double
1.5 + 5.0 evaluates to 6.5
double
int
1.0 + 5 evaluates to 6.0
double
long
1.5 + 6666666667 evaluates to 6666666668.5
4.2.2 Subtract
Summary
Returns the arithmetic difference of its operands.
Operands
Left Operand
Right Operand
Example
int
int
5 - 1 evaluates to 4
int
long
5 - 6666666667 evaluates to -6666666662
int
double
5.0 - 1 evaluates to 4.0
long
long
11111111111 - 6666666667 evaluates to 4444444444
long
int
6666666667 - 5 evaluates to 6666666662
long
double
6666666667 - 1.5 evaluates to 6666666665.5
double
double
5.0 - 1.0 evaluates to 4.0
double
int
5.0 - 1 evaluates to 4.0
double
long
1.5 - 6666666667 evaluates to -6666666665.5
4.2.3 Multiply
Summary
Returns the arithmetic product of its operands.
Operands
Left Operand
Right Operand
Example
int
int
5 * 2 evaluates to 10
int
long
2 * 6666666667 evaluates to 13333333334
int
double
5 * 2.0 evaluates to 10.0
long
long
6666666667 * long::parse('2') evaluates to 13333333334
long
int
6666666667 * 2 evaluates to 13333333334
long
double
6666666667 * 1.7 evaluates to 11333333333.9
double
double
5.0 * 2.0 evaluates to 10.0
double
int
5.0 * 2 evaluates to 10.0
double
long
1.7 * 6666666667 evaluates to 11333333333.9
4.2.4 Divide
Summary
Returns the arithmetic quotient of its operands.
Operands
Left Operand
Right Operand
Example
int
int
10 / 2 evaluates to 5
int
long
10 / 10000000000 evaluates to 0.000000001
int
double
8 / 2.0 evaluates to 4.0
long
long
13333333334 / 6666666667 evaluates to 2
long
int
13333333334 / 2 evaluates to 6666666667
long
double
13333333334 / 2.0 evaluates to 6666666667.0
double
double
9.0 / 2.0 evaluates to 4.5
double
int
6.0 / 3 evaluates to 2.0
double
long
20000000000.0 / 10000000000 evaluates to 2.0
Remarks
If the divisor is zero, then an error is raised.
4.2.5 Mod
Summary
Returns the remainder after dividing its first operand by its second.
Operands
Left Operand
Right Operand
Example
int
int
5 % 3 evaluates to 2
int
long
10 % 6666666667 evaluates to 10
int
double
5 % 3.5 evaluates to 1.5
long
long
13333333334 % 6666666667 evaluates to 0
long
int
6666666667 % 10 evaluates to 7
long
double
6666666667 % 3.5 evaluates to 3.0
double
double
9.0 % 4.7 evaluates to 4.3
double
int
8.5 % 2 evaluates to 0.5
double
long
20000000000.0 % 6666666667 evaluates to 6666666666.0
Remarks
If the divisor is zero, then an error is raised.
4.2.6 Equal
Summary
Returns true if and only if the value of the first operand is equal to the
value of the second operand.
Operands
Left Operand
Right Operand
Example
int
int
5 == 3 evaluates to false
int
long
5 == 6666666667 evaluates to false
int
double
6 == 6.0 evaluates to true
long
long
6666666667 == 6666666667 evaluates to true
long
int
6666666667 == 665 evaluates to false
long
double
6666666667 == 6666666667.0 evaluates to true
double
double
9.5 == 6.7 evaluates to false
double
int
8.5 == 8 evaluates to false
double
long
8.5 == 6666666667 evaluates to false
4.2.7 Inequal
Summary
Returns true if and only if the value of the first operand is not equal to the
value of the second operand.
Operands
Left Operand
Right Operand
Example
int
int
5 != 3 evaluates to true
int
long
5 != 6666666667 evaluates to true
int
double
6 != 6.0 evaluates to false
long
long
6666666667 != 6666666667 evaluates to false
long
int
6666666667 != 665 evaluates to true
long
double
6666666667 != 6666666667.0 evaluates to false
double
double
9.5 != 6.7 evaluates to true
double
int
8.5 != 8 evaluates to true
double
long
8.5 != 6666666667 evaluates to true
4.2.8 Greater than
Summary
Returns true if and only if the first operand is greater than the
second operand.
Operands
Left Operand
Right Operand
Example
int
int
5 > 3 evaluates to false
int
long
5 > 6666666667 evaluates to false
int
double
6 > 4.0 evaluates to true
long
long
6666666667 > 6666666667 evaluates to false
long
int
6666666667 > 665 evaluates to true
long
double
6666666667 > 6666666667.0 evaluates to false
double
double
9.5 > 9.5 evaluates to false
double
int
8.3 > 9 evaluates to false
double
long
8.5 > 6666666667 evaluates to false
4.2.9 Greater than or equal
Summary
Returns true if and only if the first operand is greater than or
equal to second operand.
Operands
Left Operand
Right Operand
Example
int
int
5 >= 3 evaluates to false
int
long
5 >= 6666666667 evaluates to false
int
double
6 >= 4.0 evaluates to true
long
long
6666666667 >= 6666666667 evaluates to true
long
int
6666666667 >= 665 evaluates to true
long
double
6666666667 >= 6666666667.0 evaluates to true
double
double
9.5 >= 9.5 evaluates to true
double
int
8.3 >= 9 evaluates to false
double
long
8.5 >= 6666666667 evaluates to false
4.2.10 Less than
Summary
Returns true if and only if the first operand is less than the
second operand.
Operands
Left Operand
Right Operand
Example
int
int
5 < 3 evaluates to false
int
long
5 < 6666666667 evaluates to true
int
double
6 < 7.0 evaluates to true
long
long
6666666667 < 6666666667 evaluates to false
long
int
6666666667 < 665 evaluates to false
long
double
6666666667 < 6666666667.0 evaluates to false
double
double
9.5 < 9.5 evaluates to false
double
int
8.3 < 9 evaluates to true
double
long
8.5 < 6666666667 evaluates to true
4.2.11 Less than or equal
Summary
Returns true if and only if the first operand is less than or
equal to second operand.
Operands
Left Operand
Right Operand
Example
int
int
5 <= 3 evaluates to false
int
long
5 <= 6666666667 evaluates to true
int
double
6 <= 7.0 evaluates to true
long
long
6666666667 <= 6666666667 evaluates to true
long
int
6666666667 <= 665 evaluates to false
long
double
6666666667 <= 6666666667.0 evaluates to true
double
double
9.5 <= 9.5 evaluates to true
double
int
8.3 <= 9 evaluates to true
double
long
8.5 <= 6666666667 evaluates to true
4.2.12 Unary plus
Summary
Returns its operand with the sign unchanged. Semantically, this operation
performs no operation.
Operands
Operand
Example
int
(+1) evaluates to 1
long
(+6666666667) evaluates to 6666666667
double
(+1.5) evaluates to 1.5
4.2.13 Unary minus
Summary
Returns its operand with the sign reversed.
If the operand is positive, its negative is returned; if it is negative, its
positive is returned.
Operands
Operand
Example
int
(-1) evaluates to -1
long
(-6666666667) evaluates to -6666666667
double
(-9.6) evaluates to -9.6
4.3 Operators on Boolean Values
The following operators are supported on boolean values:
== operator
!= operator
> operator
>= operator
< operator
<= operator
and operator
or operator
4.3.1 Equal
Summary
Returns true if both operands are true or if both
operands are false.
Examples
4.3.2 Inequal
Summary
Returns true if the first operand is true and the
second operand is false, or the first operand is false
and the second operand is true.
Examples
4.3.3 Greater than
Summary
Returns true if the first operand is true and the
second operand is false; otherwise, returns false.
Examples
4.3.4 Greater than or equal
Summary
Returns true if the first operand is true and the
second operand is false, or both operands are either true
or false.
Examples
4.3.5 Less than
Summary
Returns true if the first operand is false and the
second operand is true; otherwise, returns false.
Examples
4.3.6 Less than or equal
Summary
Returns true if the first operand is false and the
second operand is true, or both operands are either true
or false.
Examples
4.3.7 Logical and
Summary
Returns true if both operands are true,
otherwise returns false.
Examples
<if test="${A and B}">
4.3.8 Logical or
Summary
Returns true if either operand is true,
otherwise returns false.
Examples
<if test="${A or B}">
4.4 Operators on String Values
The following operators are supported on string values:
+ operator
== operator
!= operator
> operator
>= operator
< operator
<= operator
4.4.1 Concat
Summary
Returns the concatenation of both string operands.
Examples
4.4.2 Equal
Summary
Returns true if the value of the left operand is the same as the
value of the right operand.
Remarks
The comparison is case-sensitive and culture-insensitive.
4.4.3 Inequal
Summary
Returns true if the value of the first operand is not the same as
the value of the second operand.
Remarks
The comparison is case-sensitive and culture-insensitive.
4.4.4 Greater than
Summary
Returns true if the first operand is greater than the seconds
operand.
Remarks
The comparison is case-sensitive and culture-insensitive.
4.4.5 Greater than or equal
Summary
Returns true if the first operand is greater than or equal to the
seconds operand.
Remarks
The comparison is case-sensitive and culture-insensitive.
4.4.6 Less than
Summary
Returns true if the first operand is less than the seconds
operand.
Remarks
The comparison is case-sensitive and culture-insensitive.
4.4.7 Less than or equal
Summary
Returns true if the first operand is less than or equal to the
seconds operand.
Remarks
The comparison is case-sensitive and culture-insensitive.
4.5 Operators on TimeSpan and DateTime Values
The following operators are supported on timespan and datetime values:
+ operator
- operator
== operator
!= operator
> operator
>= operator
< operator
<= operator
4.5.1 Add
Summary
Returns the result of adding the value of the left operand to the value of the
right operand.
Operands
Left Operand
Right Operand
Example
datetime
timespan
datetime::now() + timespan::from-days(10)
evaluates to a datetime 10 days in the future
timespan
timespan
timespan::from-seconds(30) + timespan::from-minutes(10)
evaluates to a timespan representing a duratio of 10 minutes and 30
seconds
4.5.2 Subtract
Summary
Returns the result of subtracting the value of the right operand
from the value of the left operand.
Operands
Left Operand
Right Operand
Example
datetime
datetime
(datetime::now() + timespan::from-days(10)) - datetime::now
evaluates to a timespan representing a duration of 10 days
datetime
timespan
datetime::now() - timespan::from-days(3) evaluates
to a datetime 3 days in the past
timespan
timespan
timespan::from-minutes(15) - timespan::from-minutes(10) evaluates
to a timespan representing 5 minutes
4.5.3 Equal
Summary
Returns true if the value of the left operand is the same as the
value of the right operand.
Operands
Left Operand
Right Operand
Example
datetime
datetime
datetime::now() == (datetime::now() + timespan::from-days(10)) evaluates
to false
timespan
timespan
timespan::from-seconds(30) == timespan::from-seconds(30) evaluates
to true
4.5.4 Inequal
Summary
Returns true if the value of the left operand is not the same as
the value of the right operand.
Operands
Left Operand
Right Operand
Example
datetime
datetime
datetime::now() != (datetime::now() + timespan::from-days(10)) evaluates
to true
timespan
timespan
timespan::from-seconds(30) != timespan::from-seconds(30) evaluates
to false
4.5.5 Greater than
Summary
Returns true if the value of the left operand is greater than the
value of the right operand.
Operands
Left Operand
Right Operand
Example
datetime
datetime
datetime::now() > (datetime::now() + timespan::from-days(10)) evaluates
to false
timespan
timespan
timespan::from-seconds(30) > timespan::from-seconds(30) evaluates
to false
4.5.6 Greater than or equal
Summary
Returns true if the value of the left operand is greater than or
equal to the value of the right operand.
Operands
Left Operand
Right Operand
Example
datetime
datetime
datetime::now() >= (datetime::now() + timespan::from-days(10)) evaluates
to false
timespan
timespan
timespan::from-seconds(30) >= timespan::from-seconds(30) evaluates
to true
4.5.7 Less than
Summary
Returns true if the value of the left operand is less than the
value of the right operand.
Operands
Left Operand
Right Operand
Example
datetime
datetime
datetime::now() < (datetime::now() + timespan::from-days(10)) evaluates
to true
timespan
timespan
timespan::from-seconds(30) < timespan::from-seconds(30) evaluates
to false
4.5.8 Less than or equal
Summary
Returns true if the value of the left operand is less than the
value of the right operand.
Operands
Left Operand
Right Operand
Example
datetime
datetime
datetime::now() <= (datetime::now() + timespan::from-days(10)) evaluates
to true
timespan
timespan
timespan::from-seconds(30) <= timespan::from-seconds(30) evaluates
to true
4.6 Operators on Version Values
The following operators are supported on version values:
== operator
!= operator
> operator
>= operator
< operator
<= operator
4.6.1 Equal
Summary
Returns true if the value of the left operand is the same as the
value of the right operand.
Operands
Left Operand
Right Operand
Example
version
version
version::parse('1.2') == version::parse('1.2') evaluates
to true
4.6.2 Inequal
Summary
Returns true if the value of the left operand is not the same as
the value of the right operand.
Operands
Left Operand
Right Operand
Example
version
version
version::parse('1.2') != version::parse('1.3.1') evaluates
to true
4.6.3 Greater than
Summary
Returns true if the value of the left operand is greater than the
value of the right operand.
Operands
Left Operand
Right Operand
Example
version
version
version::parse('1.2') > version::parse('1.3.1') evaluates
to false
4.6.4 Greater than or equal
Summary
Returns true if the value of the left operand is greater than or
equal to the value of the right operand.
Operands
Left Operand
Right Operand
Example
version
version
version::parse('1.2') >= version::parse('1.2') evaluates
to true
4.6.5 Less than
Summary
Returns true if the value of the left operand is less than the
value of the right operand.
Operands
Left Operand
Right Operand
Example
version
version
version::parse('1.2') < version::parse('1.3.1') evaluates
to true
4.6.6 Less than or equal
Summary
Returns true if the value of the left operand is less than or
equal to the value of the right operand.
Operands
Left Operand
Right Operand
Example
version
version
version::parse('1.2') <= version::parse('1.2') evaluates
to true
A project can have a set of properties. These might be set in the
buildfile by the <property> task, or
might be set outside NAnt. A property has a name and a value. Properties
may be used in the value of task attributes. This is done by placing the
property name between "${" and "}" in the attribute
value. Properties may also be used in expressions.
2 Naming rules
A property name is a string of the following characters:
letters (A-Z, a-z),
digits (0-9),
underscore characters (_),
dash characters (-),
dot characters (.),
In addition, a valid property name must start with a letter or an underscore and
must end with a letter, digit or an uderscore.
Examples of valid property names include:
propertyname
property.name.with.dots
property-name-with-dashes
property.name-with.both-dots.and-dashes
__prop---3-erty__
__prop.1...erty__
property1
property1.0
property2.0.0
_property-2-1__
property-1-name_
property-1.0-name
The following property names are not valid in NAnt:
!@#!@$!@ (contains illegal characters)
.aaaaa (starts with a dot)
-aaaaa (starts with a dash)
1aaaaa (starts with a digit)
aaaaa.aaa.a.a.a.a- (ends with a dash)
aaaaa.aaa.a.a.a.a. (ends with a dot)
3 Built-in Properties
NAnt has these built-in properties:
Property
Description
nant.version
Deprecated. The version of NAnt.
nant.filename
Deprecated. The full path to the NAnt assembly.
nant.location
Deprecated. The base directory of the NAnt assembly.
nant.project.basedir
Deprecated. The absolute path of the project's basedir.
nant.project.buildfile
Deprecated. The absolute path of the buildfile.
nant.project.name
Deprecated. The name of the project.
nant.project.default
Deprecated. The name of the project's default target.
nant.onsuccess
The name of a target to be executed when the build succeeds.
nant.onfailure
The name of a target to be executed when the build fails.
3.1 Framework related Properties:
Property
Description
nant.settings.currentframework
The current target framework, eg. 'net-1.0'.
nant.settings.currentframework.description
Deprecated. Description of the current target framework.
nant.settings.currentframework.frameworkdirectory
Deprecated. The framework directory of the current target framework.
nant.settings.currentframework.sdkdirectory
Deprecated. The framework SDK directory of the current target framework.
Deprecated. The framework assembly directory of the current target
framework.
nant.settings.currentframework.runtimeengine
Deprecated. The runtime engine of the current target framework if used
eg. mono.exe.
3.2 Platform related Properties:
Property
Description
nant.platform.name
Deprecated. The name of the platform on which NAnt is currently running
- either win32 or unix.
nant.platform.win32
Deprecated. Holds the value true if NAnt is running on the
win32 platform; otherwise, false.
nant.platform.unix
Deprecated. Holds the value true if NAnt is running on the
unix platform; otherwise, false.
4 Read-only Properties
A property can be explicitly marked read-only by setting the
"readonly" attribute on the <property>
task to true.
The value of a read-only property cannot be modified after it has been set.
When attempting to override a read-only property using the
<property> task, the new value will be ignored and a warning
message will be output in the build log. Attempting to override read-only
properties using any other means (eg. other tasks) will result in a build
failure.
Note: properties set on the command-line are always read-only.
5 Global Properties
Properties that should be accessible to all build files on a system can be
defined in the <properties> node of the NAnt configuration
file (NAnt.exe.config).
By changing the value of the property in the NAnt configuration file, the
updated value will be accessible to all build files on the system:
<?xml version="1.0"?>
<configuration>
...
<nant>
...
<properties>
<!-- properties defined here are accessible to all build files -->
<property name="company.name" value="Foo Ltd." readonly="true" />
</properties>
</nant>
</configuration>
Individual build files can then use this property:
The code language in which the AssemblyInfo file should be generated.
True
output
file
Name of the AssemblyInfo file to generate.
True
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Nested Elements:
<attributes>
The assembly-level attributes to generate.
<attribute>
Represents an assembly-level attribute.
Parameters
Attribute
Type
Description
Required
type
string
Typename of the assembly-level attribute.
True
asis
bool
If true then the value of the attribute will be set as is, without actually looking for a matching constructor or named properties. The default is false.
False
if
bool
Indicates if the attribute should be generated.
False
unless
bool
Indicates if the attribute should be not generated.
Create a C# AssemblyInfo file containing an attribute with multiple named properties by setting the asis attribute on the AssemblyAttribute element to true.
[This is preliminary documentation and subject to change.]
Sets a property in the current project.
Note: NAnt uses a number of predefined properties.
Parameters
Attribute
Type
Description
Required
name
string
The name of the NAnt property to set.
True
value
string
The value to assign to the NAnt property.
This attribute's properties will not be automatically expanded!
True
dynamic
bool
Specifies whether references to other properties should not be expanded when the value of the property is set, but expanded when the property is actually used. By default, properties will be expanded when set.
False
overwrite
bool
Specifies whether the value of a property should be overwritten if the property already exists (unless the property is read-only). The default is true.
False
readonly
bool
Specifies whether the property is read-only or not. The default is false.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Examples
Define a debug property with value true.
<property name="debug" value="true" />
Use the user-defined debug property.
<property name="trace" value="${debug}" />
Define a read-only property. This is just like passing in the param on the command line.
[This is preliminary documentation and subject to change.]
Disassembles any portable executable (PE) file that contains intermediate language (IL) code.
Files are only disassembled if the input file is newer than the output file, or if the output file does not exist. However, you can explicitly force files to be disassembled with the rebuild attribute.
A <fileset> can be used to select files to disassemble. To use a <fileset>, the todir attribute must be set. The file name of the output file will be equal to the file name of the input file, but with extension ".il".
Parameters
Attribute
Type
Description
Required
all
bool
Specifies whether or not the disassembler should combine the /HEADER, /BYTE, and /TOKENS options. The default is false.
False
bytes
bool
Specifies whether or not the disassembler should generate the IL stream bytes (in hexadecimal notation) as instruction comments. The default is false.
False
header
bool
Specifies whether or not the disassembler should include PE header information and runtime header information in the output. The default is false.
False
input
file
Specifies the PE file to disassemble.
False
item
string
Instructs the disassembler to disassemble the specified item only.
False
linenumbers
bool
Specifies whether or not the disassembler should include references to original source lines. The default is false.
False
noil
bool
Specifies whether or not the disassembler should suppress ILASM code output. The default is false.
False
output
file
Specifies the name of the output file created by the disassembler.
False
publiconly
bool
Specifies whether or not the disassembler should disassemble public items only. This is a shortcut for visibility="pub". The default is false.
False
quoteallnames
bool
Specifies whether or not the disassembler should enclose all names in single quotation marks. By default, only names that don't match the ILASM definition of a simple name are quoted. The default is false.
False
rawexceptionhandling
bool
Specifies whether or not the disassembler should generate structured exception handling clauses in canonical (label) form. The default is false.
False
rebuild
bool
Instructs NAnt to rebuild the output file regardless of the file timestamps. The default is false.
False
source
bool
Specifies whether or not the disassembler should generate original source lines as comments. The default is false.
False
todir
directory
Specifies the directory to which outputs will be stored.
False
tokens
bool
Specifies whether or not the disassembler should generate metadata token values as comments. The default is false.
False
unicode
bool
Specifies whether or not the disassembler should use the UNICODE encoding when generating the output. The default is ANSI.
False
utf8
bool
Specifies whether or not the disassembler should use the UTF-8 encoding when generating the output. The default is ANSI.
False
visibility
string
Instructs the disassembler to disassemble only the items with the specified visibility. Possible values are PUB, PRI, FAM, ASM, FAA, FOA, PSC, or any combination of them separated by +.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Framework-configurable parameters
Attribute
Type
Description
Required
exename
string
The name of the executable that should be used to launch the external program.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
[This is preliminary documentation and subject to change.]
Load a text file into a single property.
Unless an encoding is specified, the encoding associated with the system's current ANSI code page is used.
An UTF-8, little-endian Unicode, and big-endian Unicode encoded text file is automatically recognized, if the file starts with the appropriate byte order marks.
[This is preliminary documentation and subject to change.]
Executes an alternate set of task or type definition depending on conditions that are individually set on each group.
The <choose> task selects one among a number of possible alternatives. It consists of a sequence of <when> elements followed by an optional <otherwise> element.
Each <when> element has a single attribute, test, which specifies an expression. The content of the <when> and <otherwise> elements is a set of nested tasks.
The content of the first, and only the first, <when> element whose test is true is executed. If no <when> element is true, the content of the <otherwise> element is executed. If no <when> element is true, and no <otherwise> element is present, nothing is done.
Parameters
Attribute
Type
Description
Required
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Nested Elements:
<when>
One or more alternative sets of tasks to execute.
Groups a set of tasks to execute when a condition is met.
Parameters
Attribute
Type
Description
Required
test
bool
Used to test arbitrary boolean expression.
True
</when>
<otherwise>
The set of tasks to execute if none of the When elements are true.
Executes embedded tasks/elements in the order in which they are defined.
</otherwise>
Examples
Execute alternate set of tasks depending on the configuration being built.
<choose>
<when test="${build.config == 'Debug'}">
<!-- compile app in debug configuration -->
...
</when>
<when test="${build.config == 'Release'}">
<!-- compile app in release configuration -->
...
</when>
<otherwise>
<fail>Build configuration '${build.config}' is not supported!</fail>
</otherwise>
</choose>
Define a sources patternset holding an alternate set of patterns depending on the configuration being built.
Executes a set of tasks, and optionally catches a build exception to allow recovery or rollback steps to be taken, or to define some steps to be taken regardless if the tasks succeed or fail, or both.
[This is preliminary documentation and subject to change.]
Exports a cvs module in preperation for a release (i.e. the CVS version folders are not exported).
Parameters
Attribute
Type
Description
Required
date
datetime
Specify the revision date to update to. The version of the file that existed at the date specified is retrieved.
False
force-head
bool
Indicates whether the head revision should be used if the revison specified by revision or the date tags are not found. The default is false.
False
no-shortening
bool
No shortening. Do not shorten module paths if -d specified.
False
overridedir
string
Specify a directory name to replace the module name. Valid names include any valid filename, excluding path information.
False
recursive
bool
If a directory is specified indicates whether sub-directories should also be processed.
False
revision
string
Specify the revision to update the file to. This corresponds to the "sticky-tag" of the file.
False
commandline
string
Command-line arguments for the program. The command line arguments are used to specify any cvs command options that are not available as attributes. These are appended after the command itself and are additive to whatever attributes are currently specified.
False
compressionlevel
int
Compression level to use for all net traffic. This should be a value from 1-9.
NOTE: This is not available on sharpcvslib.
False
cvsfullpath
file
The full path to the cvs binary used. The cvs tasks will attempt to "guess" the location of your cvs binary based on your path. If the task is unable to resolve the location, or resolves it incorrectly this can be used to manually specify the path.
False
cvsroot
string
The cvs root variable has the following components:
[protocol]:[username]@[servername]:[server path]
protocol: ext, pserver, ssh (sharpcvslib); if you are not using sharpcvslib consult your cvs documentation.
username: [username]
servername: cvs.sourceforge.net
server path: /cvsroot/nant
False
cvsrsh
file
The executable to use for ssh communication.
False
destination
directory
Destination directory for the local sandbox. If destination is not specified then the current directory is used.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
module
string
The module to perform an operation on.
False
passfile
file
The full path to the cached password file. If not specified then the environment variables are used to try and locate the file.
False
password
string
Deprecated. The password for logging in to the repository.
False
quiet
bool
Indicates if the output from the cvs command should be supressed. The default is false.
False
readonly
bool
true if the sandbox files should be checked out in read only mode. The default is false.
False
readwrite
bool
true if the sandbox files should be checked out in read/write mode. The default is true.
False
reallyquiet
bool
Indicates if the output from the cvs command should be stopped. The default is false.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
usesharpcvslib
bool
true if the SharpCvsLib binaries that come bundled with NAnt should be used to perform the cvs commands, false otherwise.
You may also specify an override value for all cvs tasks instead of specifying a value for each. To do this set the property sourcecontrol.usesharpcvslib to false.
If you choose not to use SharpCvsLib to checkout from cvs you will need to include a cvs.exe binary in your path.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
Export NAnt revision named your_favorite_revision_here to the folder c:\src\nant\replacement_for_module_directory_name. **NOTE**: filesets names for the export task must be prefixed with the module name. This is different than other tasks.
[This is preliminary documentation and subject to change.]
Executes the code contained within the task.
Code
The <script> task must contain a single code element, which in turn contains the script code.
This code can include extensions such as functions, or tasks. Once the script task has executed those extensions will be available for use in the buildfile.
If no extensions have been defined, a static entry point named ScriptMain - which must have a single Project argument - is required.
Namespaces
The following namespaces are imported by default:
System
System.Collections
System.IO
System.Text
NAnt.Core
NAnt.Core.Attributes
Assembly References
The assembly references that are specified will be used to compile the script, and will be loaded into the NAnt appdomain.
By default, only the NAnt.Core and mscorlib assemblies are referenced.
Parameters
Attribute
Type
Description
Required
language
string
The language of the script block. Possible values are "VB", "vb", "VISUALBASIC", "C#", "c#", "CSHARP". "JS", "js", "JSCRIPT" "VJS", "vjs", "JSHARP" or a fully-qualified name for a class implementing CodeDomProvider.
True
mainclass
string
The name of the main class containing the static ScriptMain entry point.
False
prefix
string
The namespace prefix for any custom functions defined in the script. If ommitted the prefix will default to 'script'
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
Represents an element of which the XML is processed by its parent task or type.
</code>
Examples
Run C# code that writes a message to the build log.
<script language="C#">
<code>
<![CDATA[
public static void ScriptMain(Project project) {
project.Log(Level.Info, "Hello World from a script task using C#");
}
]]>
</code>
</script>
Run Visual Basic.NET code that writes a message to the build log.
<script language="VB">
<code>
<![CDATA[
Public Shared Sub ScriptMain(project As Project)
project.Log(Level.Info, "Hello World from a script task using Visual Basic.NET")
End Sub
]]>
</code>
</script>
Define a custom task and call it using C#.
<script language="C#" prefix="test" >
<code>
<![CDATA[
[TaskName("usertask")]
public class TestTask : Task {
#region Private Instance Fields
private string _message;
#endregion Private Instance Fields
#region Public Instance Properties
[TaskAttribute("message", Required=true)]
public string FileName {
get { return _message; }
set { _message = value; }
}
#endregion Public Instance Properties
#region Override implementation of Task
protected override void ExecuteTask() {
Log(Level.Info, _message.ToUpper());
}
#endregion Override implementation of Task
}
]]>
</code>
</script>
<usertask message='Hello from UserTask'/>
[This is preliminary documentation and subject to change.]
Copies a file, a directory, or set of files to a new file or directory.
Files are only copied if the source file is newer than the destination file, or if the destination file does not exist. However, you can explicitly overwrite files with the overwrite attribute.
Entire directory structures can be copied to a new location. For this to happen, the following criteria must be met:
Everything in the fileset is included
The directory structure is not flattened
Empty directories are included
Destination directory does not exist
If any of these items are not met, then the files within the source directory will be copied over instead of the entire directory structure.
When a <fileset> is used to select files or directories to copy, the todir attribute must be set. Files that are located under the base directory of the <fileset> will be copied to a directory under the destination directory matching the path relative to the base directory of the <fileset>, unless the flatten attribute is set to true.
Files that are not located under the the base directory of the <fileset> will be copied directly under to the destination directory, regardless of the value of the flatten attribute.
Encoding
Unless an encoding is specified, the encoding associated with the system's current ANSI code page is used.
An UTF-8, little-endian Unicode, and big-endian Unicode encoded text file is automatically recognized, if the file starts with the appropriate byte order marks.
Note: If you employ filters in your copy operation, you should limit the copy to text files. Binary files will be corrupted by the copy operation.
Parameters
Attribute
Type
Description
Required
file
file
The file to copy.
False
flatten
bool
Ignore directory structure of source directory, copy all files into a single directory, specified by the todir attribute. The default is false.
False
includeemptydirs
bool
Copy any empty directories included in the <fileset>. The default is true.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
False
Nested Elements:
<arg>
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
A single command-line argument containing a space character.
<arg value="-l -a" />
Two separate command-line arguments.
<arg line="-l -a" />
A single command-line argument with the value \dir;\dir2;\dir3 on DOS-based systems and /dir:/dir2:/dir3 on Unix-like systems.
<arg path="/dir;/dir2:\dir3" />
</arg>
Examples
Adds all public classes contained in myTest.dll to a COM+ application and produces the myTest.tlb type library. If the application already exists, it is overwritten.
Adds all public classes contained in myTest.dll to myTargetApp and produces the myTest.tlb type library. If the application already exists, it is overwritten.
[This is preliminary documentation and subject to change.]
Wraps al.exe, the assembly linker for the .NET Framework.
All specified sources will be embedded using the /embed flag. Other source types are not supported.
Parameters
Attribute
Type
Description
Required
output
file
The name of the output file for the assembly manifest.
True
target
string
The target type (one of lib, exe, or winexe).
True
algid
string
Specifies an algorithm (in hexadecimal) to hash all files in a multifile assembly except the file that contains the assembly manifest. The default algorithm is CALG_SHA1.
False
company
string
Specifies a string for the Company field in the assembly.
False
configuration
string
Specifies a string for the Configuration field in the assembly.
False
copyright
string
Specifies a string for the Copyright field in the assembly.
False
culture
string
The culture string associated with the output assembly. The string must be in RFC 1766 format, such as "en-US".
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
supportstemplate
bool
Indicates whether the assembly linker for a given target framework supports the "template" option, which takes an assembly from which to get all options except the culture field. The default is true.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Links files using link.exe, Microsoft's Incremental Linker.
This task is intended for version 7.00.9466 of link.exe.
Parameters
Attribute
Type
Description
Required
output
file
The output file.
True
moduledefinition
file
The name of a module-definition file (.def) to be passed to the linker.
False
options
string
Options to pass to the compiler.
False
pdbfile
file
A user-specified name for the program database (PDB) that the linker creates. The default file name for the PDB has the base name of the output and the extension .pdb.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Framework-configurable parameters
Attribute
Type
Description
Required
exename
string
The name of the executable that should be used to launch the external program.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
If true then the element will be processed; otherwise, skipped. The default is true.
False
unless
bool
If true then the element will be skipped; otherwise, processed. The default is false.
False
</symbol>
</symbols>
<ignorelibraries>
Names of libraries that you want the linker to ignore when it resolves external references.
<library>
Represents a library.
Parameters
Attribute
Type
Description
Required
name
string
The name of the library.
True
if
bool
If true then the element will be processed; otherwise, skipped. The default is true.
False
unless
bool
If true then the element will be skipped; otherwise, processed. The default is false.
False
</library>
</ignorelibraries>
<arg>
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Compiles VS.NET solutions (or sets of projects), automatically determining project dependencies from inter-project references.
This task support the following projects:
Visual Basic .NET
Visual C# .NET
Visual J# .NET
Visual C++ .NET
Note: Right now, only Microsoft Visual Studio .NET 2002 and 2003 solutions and projects are supported. Support for .NET Compact Framework projects is also not available at this time.
The <solution> task also supports the model of referencing projects by their output filenames, rather than referencing them inside the solution. It will automatically detect the existance of a file reference and convert it to a project reference. For example, if project "A" references the file in the release output directory of project "B", the <solution> task will automatically convert this to a project dependency on project "B" and will reference the appropriate configuration output directory at the final build time (ie: reference the debug version of "B" if the solution is built as debug).
Note: The <solution> task expects all project files to be valid XML files.
Resx Files
When building a project for a down-level target framework, special care should be given to resx files. Resx files (can) contain references to a specific version of CLR types, and as such are only upward compatible.
For example: if you want to be able to build a project both as a .NET 1.0 and .NET 1.1 assembly, the resx files should only contain references to .NET 1.0 CLR types. Failure to do this may result in a InvalidCastException failure at runtime on machines with only the .NET Framework 1.0 installed.
Parameters
Attribute
Type
Description
Required
configuration
string
The name of the solution configuration to build.
True
enablewebdav
bool
Allow the task to use WebDAV for retrieving/compiling the projects within solution. Use of WebMap is preferred over WebDAV. The default is false.
False
includevsfolders
bool
Includes Visual Studio search folders in reference search path. The default is true.
False
outputdir
directory
The directory where compiled targets will be placed. This overrides path settings contained in the solution/project.
False
platform
string
The name of platform to build the solution for.
False
solutionfile
file
The name of the VS.NET solution file to build.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
Set of properties set at solution level. Builders for projects in solution may or may not use them.
Sets a property in the current project.
Note: NAnt uses a number of predefined properties.
Parameters
Attribute
Type
Description
Required
name
string
The name of the NAnt property to set.
True
value
string
The value to assign to the NAnt property.
This attribute's properties will not be automatically expanded!
True
dynamic
bool
Specifies whether references to other properties should not be expanded when the value of the property is set, but expanded when the property is actually used. By default, properties will be expanded when set.
False
overwrite
bool
Specifies whether the value of a property should be overwritten if the property already exists (unless the property is read-only). The default is true.
False
readonly
bool
Specifies whether the property is read-only or not. The default is false.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Examples
Define a debug property with value true.
<property name="debug" value="true" />
Use the user-defined debug property.
<property name="trace" value="${debug}" />
Define a read-only property. This is just like passing in the param on the command line.
Compiles all of the projects in the solution mapping the specific project at http://localhost/A/A.csproj to c:\inetpub\wwwroot\A\A.csproj and any URLs under http://localhost/B/[remainder] to c:\other\B\[remainder]. This allows the build to work without WebDAV.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
False
Nested Elements:
<arg>
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
Sets the mono-0.21.framework.present property to true if the Mono 0.21 framework is available on the current system and false if the framework is not available.
Sets the net-1.1.frameworksdk.present property to true if the .NET 1.1 Framework SDK is available on the current system and false if the SDK is not available.
XSLT parameters to be passed to the XSLT transformation.
<parameter>
Represents an XSLT parameter.
Parameters
Attribute
Type
Description
Required
name
string
The name of the XSLT parameter.
True
value
string
The value of the XSLT parameter.
True
if
bool
Indicates if the parameter should be added to the XSLT argument list. If true then the parameter will be added; otherwise, skipped. The default is true.
False
namespaceuri
string
The namespace URI to associate with the parameter.
False
unless
bool
Indicates if the parameter should not be added to the XSLT argument list. If false then the parameter will be added; otherwise, skipped. The default is false.
False
</parameter>
</parameters>
<extensionobjects>
XSLT extension objects to be passed to the XSLT transformation.
<extensionobject>
Represents an XSLT extension object. The object should have a default parameterless constructor and the return value should be one of the four basic XPath data types of number, string, Boolean or node set.
Parameters
Attribute
Type
Description
Required
assembly
file
The assembly which contains the XSLT extension object.
True
typename
string
The full type name of the XSLT extension object.
True
if
bool
Indicates if the extension object should be added to the XSLT argument list. If true then the extension object will be added; otherwise, skipped. The default is true.
False
namespaceuri
string
The namespace URI to associate with the extension object.
False
unless
bool
Indicates if the extension object should not be added to the XSLT argument list. If false then the extension object will be added; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
Sets properties with system information.
Sets a number of properties with information about the system environment. The intent of this task is for nightly build logs to have a record of system information so that the build was performed on.
Property
Value
<prefix>.clr.version
Common Language Runtime version number.
<prefix>.env.*
Environment variables (e.g., <prefix>.env.PATH).
<prefix>.os.platform
Operating system platform ID.
<prefix>.os.version
Operating system version.
<prefix>.os
Operating system version string.
<prefix>.os.folder.applicationdata
The directory that serves as a common repository for application-specific data for the current roaming user.
<prefix>.os.folder.commonapplicationdata
The directory that serves as a common repository for application-specific data that is used by all users.
<prefix>.os.folder.commonprogramfiles
The directory for components that are shared across applications.
<prefix>.os.folder.desktopdirectory
The directory used to physically store file objects on the desktop. Do not confuse this directory with the desktop folder itself, which is a virtual folder.
<prefix>.os.folder.programfiles
The Program Files directory.
<prefix>.os.folder.system
The System directory.
<prefix>.os.folder.temp
The temporary directory.
When the name of an environment variable is not a valid property name, the task will fail. In that case, set failonerror to true to allow that environment variable to be skipped.
Note: we advise you to use the following functions instead:
[This is preliminary documentation and subject to change.]
Runs tests using the NUnit V2.6 framework.
The haltonfailure attribute is only useful when more than one test suite is used, and you want to continue running other test suites although a test failed.
Set failonerror to false to ignore any errors and continue the build.
In order to run a test assembly built with NUnit 2.0 or 2.1 using <nunit2> task, you must add the following node to your test config file :
[This is preliminary documentation and subject to change.]
Compiles Visual J# programs using vjc, Microsoft's J# compiler.
Note: In order to have <vjc> task generate manifest resource names that match those generated by Microsoft Visual Studio.NET, the value of the prefix attribute of the <resources> element should match the "Default Package" of the J#.NET project, and the value of the dynamicprefix attribute should be set to "true".
Parameters
Attribute
Type
Description
Required
codepage
string
Specifies the code page to use for all source code files in the compilation.
Specifies the type of debugging information generated by the compiler. The default is None.
False
jcpa
string
Associate Java-language/COM package names.
False
libpath
string
Specifies the location of assemblies referenced by way of the /reference flag.
False
securescoping
bool
Specifies whether package-scoped members are accessible outside of the assembly. In other words, package scope is treated as assembly scope when emitting metadata. The default is false.
False
warninglevel
string
Specifies the warning level for the compiler to display. Valid values are 0-4. The default is 4.
False
x
string
Specifies whether to disable language extensions.
False
output
file
The output file created by the compiler.
True
target
string
Output type. Possible values are exe, winexe, library or module.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
supportsdelaysign
bool
Indicates whether the compiler for a given target framework supports the "delaysign" option. The default is false.
False
supportskeycontainer
bool
Indicates whether the compiler for a given target framework supports the "keycontainer" option. The default is false.
False
supportskeyfile
bool
Indicates whether the compiler for a given target framework supports the "keyfile" option. The default is false.
False
supportsnowarnlist
bool
Indicates whether the compiler for a given target framework supports a command line option that allows a list of warnings to be suppressed. The default is false.
False
supportswarnaserrorlist
bool
Indicates whether the compiler for a given target framework supports the "warnaserror" option that takes a list of warnings. The default is false.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
False
Nested Elements:
<nowarn>
Specifies a list of warnings that you want the compiler to suppress.
<warning>
Represents a compiler warning.
Parameters
Attribute
Type
Description
Required
number
string
A warning number, or comma-separated list of warnings, that you want the compiler to suppress or report.
True
if
bool
If true then the element will be processed; otherwise, skipped. The default is true.
False
unless
bool
If true then the element will be skipped; otherwise, processed. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Changes the file attributes of a file or set of files and directories.
<attrib> task does not have the concept of turning attributes off. Instead you specify all the attributes that you want turned on and the rest are turned off by default.
Refer to the FileAttributes enumeration in the .NET SDK for more information about file attributes.
Parameters
Attribute
Type
Description
Required
archive
bool
Set the archive attribute. The default is false.
False
file
file
The name of the file which will have its attributes set. This is provided as an alternate to using the task's fileset.
False
hidden
bool
Set the hidden attribute. The default is false.
False
normal
bool
Set the normal file attributes. This attribute is only valid if used alone. The default is false.
False
readonly
bool
Set the read-only attribute. The default is false.
False
system
bool
Set the system attribute. The default is false.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
Specifies the source type library that gets passed to the type library importer.
True
asmversion
string
Specifies the version number of the assembly to produce.
False
delaysign
bool
Specifies whether the resulting assembly should be signed with a strong name using delayed signing. The default is false.
False
keycontainer
string
Specifies the key container in which the public/private key pair should be found that should be used to sign the resulting assembly with a strong name.
False
keyfile
file
Specifies the publisher's official public/private key pair with which the resulting assembly should be signed with a strong name.
False
namespace
string
Specifies the namespace in which to produce the assembly.
False
primary
bool
Specifies whether a primary interop assembly should be produced for the specified type library. The default is false.
False
publickey
file
Specifies the file containing the public key to use to sign the resulting assembly.
False
strictref
bool
Specifies whether a type library should not be imported if all references within the current assembly or the reference assemblies cannot be resolved. The default is false.
False
sysarray
bool
Specifies whether to import a COM style SafeArray as a managed Array class type. The default is false.
False
transform
string
Specifies how to transform the metadata [.NET 1.1 or higher].
False
unsafe
bool
Specifies whether interfaces should be produced without .NET Framework security checks. The default is false.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Framework-configurable parameters
Attribute
Type
Description
Required
exename
string
The name of the executable that should be used to launch the external program.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
supportstransform
bool
Indicates whether tlbimp supports transforming metadata for a given target framework. The default is true.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
Generate an assembly named "Interop.MSVidCtlLib.dll" for the MS Video Control 1.0 Type Library, transforming any [out, retval] parameters of methods on dispinterfaces in the type library into return values in the managed library.
[This is preliminary documentation and subject to change.]
Includes an external build file.
This task is used to break your build file into smaller chunks. You can load a partial build file and have it included into the build file.
Note: Any global (project level) tasks in the included build file are executed when this task is executed. Tasks in target elements are only executed if that target is executed.
Note: The project element attributes are ignored.
Note: This task can only be in the global (project level) section of the build file.
Note: This task can only include files from the file system.
Parameters
Attribute
Type
Description
Required
buildfile
string
Build file to include.
True
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Examples
Include a task that fetches the project version from the GetProjectVersion.include build file.
[This is preliminary documentation and subject to change.]
Updates a CVS module in a local working directory.
Parameters
Attribute
Type
Description
Required
builddirs
bool
If true. new directories will be created on the local sandbox. The default is true.
False
date
datetime
Specify the revision date to update to. The version of the file that existed at the date specified is retrieved.
False
overwritelocal
bool
If true the local copy of the file will be overwritten with the copy from the remote repository. The default is false.
False
pruneempty
bool
If true empty directories copied down from the remote repository will be removed from the local sandbox. The default is true.
False
recursive
bool
Specifies if the command should be executed recursively. The default is true.
False
revision
string
Specify the revision to update the file to. This corresponds to the "sticky-tag" of the file.
False
sticky-tag
string
Sticky tag or revision to update the local file to.
False
commandline
string
Command-line arguments for the program. The command line arguments are used to specify any cvs command options that are not available as attributes. These are appended after the command itself and are additive to whatever attributes are currently specified.
False
compressionlevel
int
Compression level to use for all net traffic. This should be a value from 1-9.
NOTE: This is not available on sharpcvslib.
False
cvsfullpath
file
The full path to the cvs binary used. The cvs tasks will attempt to "guess" the location of your cvs binary based on your path. If the task is unable to resolve the location, or resolves it incorrectly this can be used to manually specify the path.
False
cvsroot
string
The cvs root variable has the following components:
[protocol]:[username]@[servername]:[server path]
protocol: ext, pserver, ssh (sharpcvslib); if you are not using sharpcvslib consult your cvs documentation.
username: [username]
servername: cvs.sourceforge.net
server path: /cvsroot/nant
False
cvsrsh
file
The executable to use for ssh communication.
False
destination
directory
Destination directory for the local sandbox. If destination is not specified then the current directory is used.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
module
string
The module to perform an operation on.
False
passfile
file
The full path to the cached password file. If not specified then the environment variables are used to try and locate the file.
False
password
string
Deprecated. The password for logging in to the repository.
False
quiet
bool
Indicates if the output from the cvs command should be supressed. The default is false.
False
readonly
bool
true if the sandbox files should be checked out in read only mode. The default is false.
False
readwrite
bool
true if the sandbox files should be checked out in read/write mode. The default is true.
False
reallyquiet
bool
Indicates if the output from the cvs command should be stopped. The default is false.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
usesharpcvslib
bool
true if the SharpCvsLib binaries that come bundled with NAnt should be used to perform the cvs commands, false otherwise.
You may also specify an override value for all cvs tasks instead of specifying a value for each. To do this set the property sourcecontrol.usesharpcvslib to false.
If you choose not to use SharpCvsLib to checkout from cvs you will need to include a cvs.exe binary in your path.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Runs NAnt on a supplied build file, or a set of build files.
By default, all the properties of the current project will be available in the new project. Alternatively, you can set inheritall to false to not copy any properties to the new project.
You can also set properties in the new project from the old project by using nested property tags. These properties are always passed to the new project regardless of the setting of inheritall. This allows you to parameterize your subprojects.
References to data types can also be passed to the new project, but by default they are not. If you set the inheritrefs to true, all references will be copied.
Parameters
Attribute
Type
Description
Required
buildfile
file
The build file to build.
False
inheritall
bool
Specifies whether current property values should be inherited by the executed project. The default is true.
False
inheritrefs
bool
Specifies whether all references will be copied to the new project. The default is false.
False
target
string
The target to execute. To specify more than one target seperate targets with a space. Targets are executed in order if possible. The default is to use target specified in the project's default attribute.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
Specifies a collection of properties that should be created in the executed project. Note, existing properties with identical names that are not read-only will be overwritten.
<property>
Sets a property in the current project.
Note: NAnt uses a number of predefined properties.
Parameters
Attribute
Type
Description
Required
name
string
The name of the NAnt property to set.
True
value
string
The value to assign to the NAnt property.
This attribute's properties will not be automatically expanded!
True
dynamic
bool
Specifies whether references to other properties should not be expanded when the value of the property is set, but expanded when the property is actually used. By default, properties will be expanded when set.
False
overwrite
bool
Specifies whether the value of a property should be overwritten if the property already exists (unless the property is read-only). The default is true.
False
readonly
bool
Specifies whether the property is read-only or not. The default is false.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Examples
Define a debug property with value true.
<property name="debug" value="true" />
Use the user-defined debug property.
<property name="trace" value="${debug}" />
Define a read-only property. This is just like passing in the param on the command line.
[This is preliminary documentation and subject to change.]
Sets properties with the current date and time.
By default the <tstamp> task displays the current date and time and sets the following properties:
tstamp.date to yyyyMMdd
tstamp.time to HHmm
tstamp.now using the default DateTime.ToString() method
To set an additional property with a custom date/time use the property and pattern attributes. To set a number of additional properties with the exact same date and time use the formatter nested element (see example).
The property to receive the date/time string in the given pattern.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Nested Elements:
<formatter>
Parameters
Attribute
Type
Description
Required
pattern
string
The string pattern to use to format the property.
True
property
string
The name of the NAnt property to set.
True
if
bool
Indicates if the formatter should be used to format the timestamp. If true then the formatter will be used; otherwise, skipped. The default is true.
False
unless
bool
Indicates if the formatter should be not used to format the timestamp. If false then the formatter will be used; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
Compiles C# programs.
Note: In order to have <csc> task generate manifest resource names that match those generated by Microsoft Visual Studio.NET, the value of the prefix attribute of the <resources> element should match the "Default Namespace" of the C# project, and the value of the dynamicprefix attribute should be set to "true".
Parameters
Attribute
Type
Description
Required
baseaddress
string
The preferred base address at which to load a DLL. The default base address for a DLL is set by the .NET Framework common language runtime.
False
checked
bool
Specifies whether an integer arithmetic statement that is not in the scope of the checked or unchecked keywords and that results in a value outside the range of the data type should cause a run-time exception. The default is false.
False
codepage
string
Specifies the code page to use for all source code files in the compilation.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
noconfig
bool
Instructs the compiler not to use implicit references to assemblies. The default is false.
False
nostdlib
bool
Instructs the compiler not to import mscorlib.dll. The default is false.
False
supportsdelaysign
bool
Indicates whether the compiler for a given target framework supports the "delaysign" option. The default is false.
False
supportsdocgeneration
bool
Specifies whether the compiler for the active target framework supports generation of XML Documentation file. The default is true.
False
supportskeycontainer
bool
Indicates whether the compiler for a given target framework supports the "keycontainer" option. The default is false.
False
supportskeyfile
bool
Indicates whether the compiler for a given target framework supports the "keyfile" option. The default is false.
False
supportslangversion
bool
Specifies whether the compiler for the active target framework supports accepting only a specific language syntax. The default is false.
False
supportsnowarnlist
bool
Indicates whether the compiler for a given target framework supports a command line option that allows a list of warnings to be suppressed. The default is false.
False
supportspackagereferences
bool
Indicates whether package references are supported by compiler for a given target framework. The default is false.
False
supportsplatform
bool
Specifies whether the compiler for the active target framework supports limiting the platform on which the compiled code can run. The default is false.
False
supportswarnaserrorlist
bool
Indicates whether the compiler for a given target framework supports the "warnaserror" option that takes a list of warnings. The default is false.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Signs delay-signed .NET Assemblies, or re-signs existing assemblies.
The delay-signing mechanism takes a fileset (named targets) and either a keyfile attribute for a file containing the public and private keys, or keycontainer to name a key container.
Parameters
Attribute
Type
Description
Required
keycontainer
string
Specifies the key container.
False
keyfile
file
Specifies the filesystem path to the signing key.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Framework-configurable parameters
Attribute
Type
Description
Required
exename
string
The name of the executable that should be used to launch the external program.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
<if test="${not file::exists(filename) or file::get-length(filename) = 0}">
<echo message="The version file ${filename} doesn't exist or is empty!" />
</if>
[This is preliminary documentation and subject to change.]
Compiles Visual Basic.NET programs.
Note: In order to have <vbc> task generate manifest resource names that match those generated by Microsoft Visual Studio.NET, the value of the prefix attribute of the <resources> element should match the "Root namespace" of the VB.NET project, and the value of the dynamicprefix attribute should be set to "false".
Parameters
Attribute
Type
Description
Required
baseaddress
string
The preferred base address at which to load a DLL. The default base address for a DLL is set by the .NET Framework common language runtime.
Specifies the type of debugging information generated by the compiler. The default is None.
False
doc
file
The name of the XML documentation file to generate. Only supported when targeting .NET 2.0 (or higher).
False
imports
string
Deprecated. Specifies whether the /imports option gets passed to the compiler.
False
nostdlib
bool
Instructs the compiler not to reference standard libraries (system.dll and VBC.RSP). The default is false. Only supported when targeting .NET 2.0 (or higher).
False
optioncompare
string
Specifies whether /optioncompare option gets passed to the compiler.
False
optionexplicit
bool
Specifies whether the /optionexplicit option gets passed to the compiler. The default is false.
False
optionoptimize
bool
Specifies whether the /optimize option gets passed to the compiler. The default is false.
False
optionstrict
bool
Specifies whether the /optionstrict option gets passed to the compiler. The default is false.
False
platform
string
Specifies which platform version of common language runtime (CLR) can run the output file.
False
removeintchecks
bool
Specifies whether the /removeintchecks option gets passed to the compiler. The default is false.
False
rootnamespace
string
Specifies whether the /rootnamespace option gets passed to the compiler.
False
output
file
The output file created by the compiler.
True
target
string
Output type. Possible values are exe, winexe, library or module.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
nostdlib
bool
Instructs the compiler not to reference standard libraries (system.dll and VBC.RSP). The default is false. Only supported when targeting .NET 2.0 (or higher).
False
supportsdelaysign
bool
Indicates whether the compiler for a given target framework supports the "delaysign" option. The default is false.
False
supportsdocgeneration
bool
Specifies whether the compiler for the active target framework supports generation of XML Documentation file. The default is false.
False
supportskeycontainer
bool
Indicates whether the compiler for a given target framework supports the "keycontainer" option. The default is false.
False
supportskeyfile
bool
Indicates whether the compiler for a given target framework supports the "keyfile" option. The default is false.
False
supportsnostdlib
bool
Specifies whether the compiler for the active target framework supports NOT referencing standard libraries (system.dll and VBC.RSP). The default is false.
False
supportsnowarnlist
bool
Indicates whether the compiler for a given target framework supports a command line option that allows a list of warnings to be suppressed. The default is false.
False
supportspackagereferences
bool
Indicates whether package references are supported by compiler for a given target framework. The default is false.
False
supportsplatform
bool
Specifies whether the compiler for the active target framework supports limiting the platform on which the compiled code can run. The default is false.
False
supportswarnaserrorlist
bool
Indicates whether the compiler for a given target framework supports the "warnaserror" option that takes a list of warnings. The default is false.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Replaces text in an XML file at the location specified by an XPath expression.
The location specified by the XPath expression must exist, it will not create the parent elements for you. However, provided you have a root element you could use a series of the tasks to build the XML file up if necessary.
Parameters
Attribute
Type
Description
Required
file
file
The name of the file that contains the XML document that is going to be poked.
True
value
string
The value that replaces the contents of the selected nodes.
True
xpath
string
The XPath expression used to select which nodes are to be modified.
True
preserveWhitespace
bool
If true then the whitespace in the resulting document will be preserved; otherwise the whitespace will be removed. The default is false.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Nested Elements:
<namespaces>
Namespace definitions to resolve prefixes in the XPath expression.
<namespace>
Represents an XML namespace.
Parameters
Attribute
Type
Description
Required
prefix
string
The prefix to associate with the namespace.
True
uri
string
The associated XML namespace URI.
True
if
bool
Indicates if the namespace should be added to the XmlNamespaceManager. If true then the namespace will be added; otherwise, skipped. The default is true.
False
unless
bool
Indicates if the namespace should not be added to the XmlNamespaceManager. list. If false then the parameter will be added; otherwise, skipped. The default is false.
False
</namespace>
</namespaces>
Examples
Change the server setting in the configuration from testhost.somecompany.com to productionhost.somecompany.com.
[This is preliminary documentation and subject to change.]
This tasks allows you to run MIDL.exe.
This task only supports a small subset of the MIDL.EXE command line switches, but you can use the options element to specify any other unsupported commands you want to specify.
Parameters
Attribute
Type
Description
Required
filename
file
Name of .IDL file to process.
True
acf
string
The /acf switch allows the user to supply an explicit ACF file name. The switch also allows the use of different interface names in the IDL and ACF files.
False
align
string
The /align switch is functionally the same as the MIDL /Zp option and is recognized by the MIDL compiler solely for backward compatibility with MkTypLib.
False
app_config
bool
The /app_config switch selects application-configuration mode, which allows you to use some ACF keywords in the IDL file. With this MIDL compiler switch, you can omit the ACF and specify an interface in a single IDL file.
False
char
string
The /char switch helps to ensure that the MIDL compiler and C compiler operate together correctly for all char and small types.
False
client
string
The /client switch directs the MIDL compiler to generate client-side C source files for an RPC interface
False
cstub
string
The /cstub switch specifies the name of the client stub file for an RPC interface.
False
dlldata
file
Specifies the file name for the generated dlldata file for a proxy DLL. The default file name Dlldata.c is used if dlldata is not specified.
False
env
string
The /env switch selects the environment in which the application runs.
False
header
file
Specifies the name of the header file.
False
iid
file
Specifies the name of the interface identifier file for a COM interface, overriding the default name obtained by adding _i.c to the IDL file name.
False
Oi
string
The /Oi switch directs the MIDL compiler to use a fully-interpreted marshaling method. The /Oic and /Oicf switches provide additional performance enhancements.
False
proxy
file
Specifies the name of the interface proxy file for a COM interface.
False
tlb
file
Specifies a file name for the type library generated by the MIDL compiler.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Framework-configurable parameters
Attribute
Type
Description
Required
exename
string
The name of the executable that should be used to launch the external program.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
False
Nested Elements:
<options>
Additional options to pass to midl.exe.
<option>
Represents an option.
Parameters
Attribute
Type
Description
Required
name
string
Name of the option.
True
if
bool
Indicates if the option should be passed to the task. If true then the option will be passed; otherwise, skipped. The default is true.
False
unless
bool
Indicates if the option should not be passed to the task. If false then the option will be passed; otherwise, skipped. The default is false.
False
value
string
Value of the option. The default is a null reference (Nothing in Visual Basic).
False
</option>
</options>
<defines>
Macro definitions to pass to mdil.exe. Each entry will generate a /D
<define>
Represents an option.
Parameters
Attribute
Type
Description
Required
name
string
Name of the option.
True
if
bool
Indicates if the option should be passed to the task. If true then the option will be passed; otherwise, skipped. The default is true.
False
unless
bool
Indicates if the option should not be passed to the task. If false then the option will be passed; otherwise, skipped. The default is false.
False
value
string
Value of the option. The default is a null reference (Nothing in Visual Basic).
False
</define>
</defines>
<undefines>
Macro undefines (/U) to pass to mdil.
<undefine>
Represents an option.
Parameters
Attribute
Type
Description
Required
name
string
Name of the option.
True
if
bool
Indicates if the option should be passed to the task. If true then the option will be passed; otherwise, skipped. The default is true.
False
unless
bool
Indicates if the option should not be passed to the task. If false then the option will be passed; otherwise, skipped. The default is false.
False
value
string
Value of the option. The default is a null reference (Nothing in Visual Basic).
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Extracts text from an XML file at the location specified by an XPath expression.
If the XPath expression specifies multiple nodes the node index is used to determine which of the nodes' text is returned.
Parameters
Attribute
Type
Description
Required
file
file
The name of the file that contains the XML document that is going to be peeked at.
True
property
string
The property that receives the text representation of the XML inside the node returned from the XPath expression.
True
xpath
string
The XPath expression used to select which node to read.
True
nodeindex
int
The index of the node that gets its text returned when the query returns multiple nodes.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Nested Elements:
<namespaces>
Namespace definitions to resolve prefixes in the XPath expression.
<namespace>
Represents an XML namespace.
Parameters
Attribute
Type
Description
Required
prefix
string
The prefix to associate with the namespace.
True
uri
string
The associated XML namespace URI.
True
if
bool
Indicates if the namespace should be added to the XmlNamespaceManager. If true then the namespace will be added; otherwise, skipped. The default is true.
False
unless
bool
Indicates if the namespace should not be added to the XmlNamespaceManager. list. If false then the parameter will be added; otherwise, skipped. The default is false.
False
</namespace>
</namespaces>
Examples
The example provided assumes that the following XML file (App.config) exists in the current build directory.
[This is preliminary documentation and subject to change.]
Tags all sources in the remote repository with a given tag.
Unlike tag, the rtag command acts only on sources that are in the repository. Any modified sources on the local file system will NOT be tagged with this command, so a commit should be performed before an rtag is done.
NOTE: Although a working directory is not necessary to perform the command one must be specified in order to remain in compliance with the cvs library.
Parameters
Attribute
Type
Description
Required
tag
string
The name of the tag to assign or remove.
True
act-on-date
datetime
Indicates the revision date of the file that the tag should be applied to.
False
act-on-tag
string
Indicates the repository tag that is acted on for the tag command. Note if move-if-exists is true then the tag specified is moved to the revision of the file on the HEAD of the branch specified.
False
force-head
bool
Indicates whether the head revision should be used if the act-on-tag or the act-on-date tags are not found.
False
move-if-exists
bool
Indicates whether the tag specified in tag should be moved to the current file revision. If the tag does not exist then it is created.
False
recursive
bool
If a directory is specified indicates whether sub-directories should also be processed.
False
remove
bool
Indicates whether the tag specified in tag should be removed or not.
False
commandline
string
Command-line arguments for the program. The command line arguments are used to specify any cvs command options that are not available as attributes. These are appended after the command itself and are additive to whatever attributes are currently specified.
False
compressionlevel
int
Compression level to use for all net traffic. This should be a value from 1-9.
NOTE: This is not available on sharpcvslib.
False
cvsfullpath
file
The full path to the cvs binary used. The cvs tasks will attempt to "guess" the location of your cvs binary based on your path. If the task is unable to resolve the location, or resolves it incorrectly this can be used to manually specify the path.
False
cvsroot
string
The cvs root variable has the following components:
[protocol]:[username]@[servername]:[server path]
protocol: ext, pserver, ssh (sharpcvslib); if you are not using sharpcvslib consult your cvs documentation.
username: [username]
servername: cvs.sourceforge.net
server path: /cvsroot/nant
False
cvsrsh
file
The executable to use for ssh communication.
False
destination
directory
Destination directory for the local sandbox. If destination is not specified then the current directory is used.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
module
string
The module to perform an operation on.
False
passfile
file
The full path to the cached password file. If not specified then the environment variables are used to try and locate the file.
False
password
string
Deprecated. The password for logging in to the repository.
False
quiet
bool
Indicates if the output from the cvs command should be supressed. The default is false.
False
readonly
bool
true if the sandbox files should be checked out in read only mode. The default is false.
False
readwrite
bool
true if the sandbox files should be checked out in read/write mode. The default is true.
False
reallyquiet
bool
Indicates if the output from the cvs command should be stopped. The default is false.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
usesharpcvslib
bool
true if the SharpCvsLib binaries that come bundled with NAnt should be used to perform the cvs commands, false otherwise.
You may also specify an override value for all cvs tasks instead of specifying a value for each. To do this set the property sourcecontrol.usesharpcvslib to false.
If you choose not to use SharpCvsLib to checkout from cvs you will need to include a cvs.exe binary in your path.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Writes a message to the build log or a specified file.
The message can be specified using the message attribute or as inline content. If neither is included - or the message contains only whitespace - then an empty message will be emitted in the output.
Macros in the message will be expanded.
When writing to a file, the level attribute is ignored.
Note: Since NAnt 0.86, a newline will no longer be implictly added when writing a message to a file.
Parameters
Attribute
Type
Description
Required
append
bool
Determines whether the <echo> task should append to the file, or overwrite it. By default, the file will be overwritten.
Note: By default, only the NDoc MSDN documenter ships as part of the NAnt distribution. To make another NDoc documenter from the NDoc V1.3.1 distribution available to the <ndoc> task, copy the documenter assembly (and possible dependencies) to the "lib" directory corresponding with the CLR you're running NAnt on (eg. <nant root>/bin/lib/net/1.1).
Parameters
Attribute
Type
Description
Required
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
<namespaces>
<namespace name="Foo.Bar">
The <b>Foo.Bar</b> namespace reinvents the wheel.
</namespace>
<namespace name="Foo.Bar.Tests">
The <b>Foo.Bar.Tests</b> namespace ensures that the Foo.Bar namespace reinvents the wheel correctly.
</namespace>
</namespaces>
[This is preliminary documentation and subject to change.]
Produces an XML report that represents the cvs changes from the given start day, to a given end date.
Parameters
Attribute
Type
Description
Required
end
datetime
The latest date to use in the cvs log command.
True
start
datetime
The earliest change to use in the cvs log command.
True
xmlfile
file
Name of the xml file that will contain the cvs log information.
True
cvsroot
string
The cvs root variable has the following components:
[protocol]:[username]@[servername]:[server path]
protocol: ext, pserver, ssh (sharpcvslib); if you are not using sharpcvslib consult your cvs documentation.
username: [username]
servername: cvs.sourceforge.net
server path: /cvsroot/nant
If the cvsroot is not specified then the directory specified by the destination attribute is searched for CVS\Root.
False
commandline
string
Command-line arguments for the program. The command line arguments are used to specify any cvs command options that are not available as attributes. These are appended after the command itself and are additive to whatever attributes are currently specified.
False
compressionlevel
int
Compression level to use for all net traffic. This should be a value from 1-9.
NOTE: This is not available on sharpcvslib.
False
cvsfullpath
file
The full path to the cvs binary used. The cvs tasks will attempt to "guess" the location of your cvs binary based on your path. If the task is unable to resolve the location, or resolves it incorrectly this can be used to manually specify the path.
False
cvsrsh
file
The executable to use for ssh communication.
False
destination
directory
Destination directory for the local sandbox. If destination is not specified then the current directory is used.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
module
string
The module to perform an operation on.
False
passfile
file
The full path to the cached password file. If not specified then the environment variables are used to try and locate the file.
False
password
string
Deprecated. The password for logging in to the repository.
False
quiet
bool
Indicates if the output from the cvs command should be supressed. The default is false.
False
readonly
bool
true if the sandbox files should be checked out in read only mode. The default is false.
False
readwrite
bool
true if the sandbox files should be checked out in read/write mode. The default is true.
False
reallyquiet
bool
Indicates if the output from the cvs command should be stopped. The default is false.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
supportsassemblyreferences
bool
Indicates whether assembly references are supported by the current target framework. The default is false.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
[This is preliminary documentation and subject to change.]
Sets project properties based on the evaluatuion of a regular expression.
The pattern attribute must contain one or more named grouping constructs, which represents the names of the properties to be set. These named grouping constructs can be enclosed by angle brackets (?<name>) or single quotes (?'name').
Note: In the build file, use the XML element < to specify <, and > to specify >.
Note: The named grouping construct must not contain any punctuation and it cannot begin with a number.
[This is preliminary documentation and subject to change.]
Converts files from one resource format to another.
Note: If no todir is specified, the resource file will be created next to the input file.
Parameters
Attribute
Type
Description
Required
input
file
Input file to process.
False
output
file
The resource file to output.
False
target
string
The target type. The default is resources.
False
todir
directory
The directory to which outputs will be stored.
False
usesourcepath
bool
Use each source file's directory as the current directory for resolving relative file paths. The default is false. Only supported when targeting .NET 2.0 (or higher).
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Framework-configurable parameters
Attribute
Type
Description
Required
exename
string
The name of the executable that should be used to launch the external program.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
supportsassemblyreferences
bool
Indicates whether assembly references are supported by the resgen tool for the current target framework. The default is false.
False
supportsexternalfilereferences
bool
Indicates whether external file references are supported by the resgen tool for the current target framework. The default is false.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
The haltonfailure or haltonerror attributes are only used to stop more than one test suite to stop running. If any test suite fails a build error will be thrown. Set failonerror to false to ignore test errors and continue build.
Parameters
Attribute
Type
Description
Required
haltonerror
bool
Stops running tests when a test causes an error. The default is false.
False
haltonfailure
bool
Stops running tests if a test fails (errors are considered failures as well). The default is false.
False
timeout
int
Cancel the individual tests if they do not finish in the specified time (measured in milliseconds). Ignored if fork is disabled.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
Specifies the directory where the output file should be written to, if usefile is true. If not specified, the output file will be written to the directory where the test module is located.
False
usefile
bool
Determines whether output should be persisted to a file. The default is false.
False
</formatter>
Examples
Run tests in the MyProject.Tests.dll assembly.
The test results are logged in results.xml and results.txt using the Xml and Plain formatters, respectively.
[This is preliminary documentation and subject to change.]
Generates a Windows Forms Control that wraps ActiveX Controls defined in an OCX.
Parameters
Attribute
Type
Description
Required
ocx
file
Filename of the .ocx file.
True
delaysign
bool
Specifies to sign the resulting control using delayed signing.
False
generatesource
bool
Determines whether C# source code for the Windows Form wrapper should be generated. The default is false.
False
keycontainer
string
Specifies the key container in which the public/private key pair should be found that should be used to sign the resulting assembly with a strong name.
False
keyfile
file
Specifies the publisher's official public/private key pair with which the resulting assembly should be signed with a strong name.
False
output
file
Filename of the generated assembly.
False
publickey
file
Specifies the file containing the public key to use to sign the resulting assembly.
False
rcw
file
Assembly to use for Runtime Callable Wrapper rather than generating new one [.NET 1.1 or higher].
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Framework-configurable parameters
Attribute
Type
Description
Required
exename
string
The name of the executable that should be used to launch the external program.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
supportsrcw
bool
Indicates whether aximp supports using an existing Runtime Callable Wrapper for a given target framework. The default is true.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
False
Nested Elements:
<arg>
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Gets a particular file from a URL source.
Options include verbose reporting and timestamp based fetches.
Currently, only HTTP and UNC protocols are supported. FTP support may be added when more pluggable protocols are added to the System.Net assembly.
The usetimestamp option enables you to control downloads so that the remote file is only fetched if newer than the local copy. If there is no local copy, the download always takes place. When a file is downloaded, the timestamp of the downloaded file is set to the remote timestamp.
Note: This timestamp facility only works on downloads using the HTTP protocol.
Parameters
Attribute
Type
Description
Required
dest
file
The file where to store the retrieved file.
True
src
string
The URL from which to retrieve a file.
True
httpproxy
string
Deprecated. If inside a firewall, proxy server/port information Format: {proxy server name}:{port number} Example: proxy.mycompany.com:8080
False
ignoreerrors
bool
Deprecated. Log errors but don't treat as fatal. The default is false.
False
timeout
int
The length of time, in milliseconds, until the request times out. The default is 100000 milliseconds.
False
usetimestamp
bool
Conditionally download a file based on the timestamp of the local copy. HTTP only. The default is false.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
[This is preliminary documentation and subject to change.]
Compiles JScript.NET programs.
Parameters
Attribute
Type
Description
Required
autoref
bool
Automatically references assemblies if they have the same name as an imported namespace or as a type annotation when declaring a variable. The default is false.
False
codepage
string
Specifies the code page to use for all source code files in the compilation.
False
nostdlib
bool
Instructs the compiler not to import standard library, and changes autoref to false. The default is false.
False
platform
string
Specifies which platform version of common language runtime (CLR) can run the output file.
False
versionsafe
bool
Causes the compiler to generate errors for implicit method overrides. The default is false.
False
warninglevel
string
Specifies the warning level for the compiler to display. Valid values are 0-4. The default is 4.
False
output
file
The output file created by the compiler.
True
target
string
Output type. Possible values are exe, winexe, library or module.
True
debug
bool
Generate debug output. The default is false.
False
define
string
Define conditional compilation symbol(s).
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
main
string
Specifies which type contains the Main method that you want to use as the entry point into the program.
False
rebuild
bool
Instructs NAnt to recompile the output file regardless of the file timestamps.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
warnaserror
bool
Instructs the compiler to treat all warnings as errors. The default is false.
False
win32icon
file
Icon to associate with the application.
False
win32res
file
Specifies a Win32 resource file (.res).
False
Framework-configurable parameters
Attribute
Type
Description
Required
exename
string
The name of the executable that should be used to launch the external program.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
supportsnowarnlist
bool
Indicates whether the compiler for a given target framework supports a command line option that allows a list of warnings to be suppressed. The default is false.
False
supportspackagereferences
bool
Indicates whether package references are supported by compiler for a given target framework. The default is false.
False
supportsplatform
bool
Specifies whether the compiler for the active target framework supports limiting the platform on which the compiled code can run. The default is false.
False
supportswarnaserrorlist
bool
Indicates whether the compiler for a given target framework supports the "warnaserror" option that takes a list of warnings. The default is false.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Tags all local sources with the specified tag.
This differs from the <cvs-rtag> task in that it acts on references to the cvs files contained in your local filesystem. As such the sticky tags and local revisions can be considered in commits. It also allows you to verify that all local files have been checked in before a tag is performed.
Parameters
Attribute
Type
Description
Required
tag
string
The name of the tag to assign or remove.
True
act-on-date
datetime
Indicates the revision date of the file that the tag should be applied to.
False
act-on-tag
string
Indicates the repository tag that is acted on for the tag command. Note if move-if-exists is true then the tag specified is moved to the revision of the file on the HEAD of the branch specified.
False
fail-if-modified
bool
Indicates whether the head revision should be used if the act-on-tag or the act-on-date tags are not found.
False
force-head
bool
Indicates whether the head revision should be used if the revision specified by act-on-tag or the act-on-date tags are not found.
False
move-if-exists
bool
Indicates whether the tag specified in tag should be moved to the current file revision. If the tag does not exist then it is created.
False
recursive
bool
If a directory is specified indicates whether sub-directories should also be processed.
False
remove
bool
Indicates whether the tag specified in tag should be removed or not.
False
commandline
string
Command-line arguments for the program. The command line arguments are used to specify any cvs command options that are not available as attributes. These are appended after the command itself and are additive to whatever attributes are currently specified.
False
compressionlevel
int
Compression level to use for all net traffic. This should be a value from 1-9.
NOTE: This is not available on sharpcvslib.
False
cvsfullpath
file
The full path to the cvs binary used. The cvs tasks will attempt to "guess" the location of your cvs binary based on your path. If the task is unable to resolve the location, or resolves it incorrectly this can be used to manually specify the path.
False
cvsroot
string
The cvs root variable has the following components:
[protocol]:[username]@[servername]:[server path]
protocol: ext, pserver, ssh (sharpcvslib); if you are not using sharpcvslib consult your cvs documentation.
username: [username]
servername: cvs.sourceforge.net
server path: /cvsroot/nant
False
cvsrsh
file
The executable to use for ssh communication.
False
destination
directory
Destination directory for the local sandbox. If destination is not specified then the current directory is used.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
passfile
file
The full path to the cached password file. If not specified then the environment variables are used to try and locate the file.
False
password
string
Deprecated. The password for logging in to the repository.
False
quiet
bool
Indicates if the output from the cvs command should be supressed. The default is false.
False
readonly
bool
true if the sandbox files should be checked out in read only mode. The default is false.
False
readwrite
bool
true if the sandbox files should be checked out in read/write mode. The default is true.
False
reallyquiet
bool
Indicates if the output from the cvs command should be stopped. The default is false.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
usesharpcvslib
bool
true if the SharpCvsLib binaries that come bundled with NAnt should be used to perform the cvs commands, false otherwise.
You may also specify an override value for all cvs tasks instead of specifying a value for each. To do this set the property sourcecontrol.usesharpcvslib to false.
If you choose not to use SharpCvsLib to checkout from cvs you will need to include a cvs.exe binary in your path.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Deletes a file, fileset or directory.
Deletes either a single file, all files in a specified directory and its sub-directories, or a set of files specified by one or more filesets.
If the file or dir attribute is set then the fileset contents will be ignored. To delete the files in the fileset ommit the file and dir attributes in the <delete> element.
If the specified file or directory does not exist, no error is reported.
Note: Read-only files cannot be deleted. Use the <attrib> task first to remove the read-only attribute.
Parameters
Attribute
Type
Description
Required
dir
directory
The directory to delete.
False
file
file
The file to delete.
False
includeemptydirs
bool
Remove any empty directories included in the <fileset>. The default is true.
False
verbose
bool
Controls whether to show the name of each deleted file or directory. The default is false.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
Macro definitions to pass to rc.exe. Each entry will generate a /d
<define>
Represents an option.
Parameters
Attribute
Type
Description
Required
name
string
Name of the option.
True
if
bool
Indicates if the option should be passed to the task. If true then the option will be passed; otherwise, skipped. The default is true.
False
unless
bool
Indicates if the option should not be passed to the task. If false then the option will be passed; otherwise, skipped. The default is false.
False
value
string
Value of the option. The default is a null reference (Nothing in Visual Basic).
False
</define>
</defines>
<arg>
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
Sends an email from nant@sourceforge.net to three recipients with a subject about the attachments. The body of the message will be the combined contents of all .txt files in the base directory. All zip files in the base directory will be included as attachments. The message will be sent using the smtpserver.anywhere.com SMTP server.
The mode in which the specified pchfile (if any) is used. The default is Use.
False
pchthroughfile
string
The path of the boundary file when generating/using the specified pchfile. If a precompiled header file is not specified then this attribute is ignored.
False
pdbfile
string
A name for the compiler-generated PDB file; can be either a file or directory name. The default is the output directory.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Framework-configurable parameters
Attribute
Type
Description
Required
exename
string
The name of the executable that should be used to launch the external program.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
Macro definitions to pass to cl.exe. Each entry will generate a /D
<define>
Represents an option.
Parameters
Attribute
Type
Description
Required
name
string
Name of the option.
True
if
bool
Indicates if the option should be passed to the task. If true then the option will be passed; otherwise, skipped. The default is true.
False
unless
bool
Indicates if the option should not be passed to the task. If false then the option will be passed; otherwise, skipped. The default is false.
False
value
string
Value of the option. The default is a null reference (Nothing in Visual Basic).
False
</define>
</defines>
<undefines>
Macro undefines (/U) to pass to cl.exe.
<undefine>
Represents an option.
Parameters
Attribute
Type
Description
Required
name
string
Name of the option.
True
if
bool
Indicates if the option should be passed to the task. If true then the option will be passed; otherwise, skipped. The default is true.
False
unless
bool
Indicates if the option should not be passed to the task. If false then the option will be passed; otherwise, skipped. The default is false.
False
value
string
Value of the option. The default is a null reference (Nothing in Visual Basic).
False
</undefine>
</undefines>
<arg>
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Executes the cvs command specified by the command attribute.
Parameters
Attribute
Type
Description
Required
command
string
The cvs command to execute.
True
commandline
string
Command-line arguments for the program. The command line arguments are used to specify any cvs command options that are not available as attributes. These are appended after the command itself and are additive to whatever attributes are currently specified.
False
compressionlevel
int
Compression level to use for all net traffic. This should be a value from 1-9.
NOTE: This is not available on sharpcvslib.
False
cvsfullpath
file
The full path to the cvs binary used. The cvs tasks will attempt to "guess" the location of your cvs binary based on your path. If the task is unable to resolve the location, or resolves it incorrectly this can be used to manually specify the path.
False
cvsroot
string
The cvs root variable has the following components:
[protocol]:[username]@[servername]:[server path]
protocol: ext, pserver, ssh (sharpcvslib); if you are not using sharpcvslib consult your cvs documentation.
username: [username]
servername: cvs.sourceforge.net
server path: /cvsroot/nant
False
cvsrsh
file
The executable to use for ssh communication.
False
destination
directory
Destination directory for the local sandbox. If destination is not specified then the current directory is used.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
module
string
The module to perform an operation on.
False
passfile
file
The full path to the cached password file. If not specified then the environment variables are used to try and locate the file.
False
password
string
Deprecated. The password for logging in to the repository.
False
quiet
bool
Indicates if the output from the cvs command should be supressed. The default is false.
False
readonly
bool
true if the sandbox files should be checked out in read only mode. The default is false.
False
readwrite
bool
true if the sandbox files should be checked out in read/write mode. The default is true.
False
reallyquiet
bool
Indicates if the output from the cvs command should be stopped. The default is false.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
usesharpcvslib
bool
true if the SharpCvsLib binaries that come bundled with NAnt should be used to perform the cvs commands, false otherwise.
You may also specify an override value for all cvs tasks instead of specifying a value for each. To do this set the property sourcecontrol.usesharpcvslib to false.
If you choose not to use SharpCvsLib to checkout from cvs you will need to include a cvs.exe binary in your path.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Sets an environment variable or a whole collection of them. Use an empty value attribute to clear a variable.
Note: Variables will be set for the current NAnt process and all child processes that NAnt spawns (compilers, shell tools, etc). If the intention is to only set a variable for a single child process, then using the <exec> task and its nested environment element might be a better option.
Note: Expansion of inline environment variables is performed using the syntax of the current platform. So on Windows platforms using the string %PATH% in the value attribute will result in the value of the PATH variable being expanded in place before the variable is set.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based environment variable. NAnt will convert it to an absolute path.
False
file
file
The value for a file-based environment variable. NAnt will convert it to an absolute filename.
False
name
string
The name of a single Environment variable to set
False
path
<path>
The value for a PATH like environment variable. You can use : or ; as path separators and NAnt will convert it to the platform's local conventions.
False
value
string
The literal value for the environment variable.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Nested Elements:
<variable>
Represents an environment variable.
Parameters
Attribute
Type
Description
Required
name
string
The name of the environment variable.
True
dir
directory
The value for a directory-based environment variable. NAnt will convert it to an absolute path.
False
file
file
The value for a file-based environment variable. NAnt will convert it to an absolute filename.
False
if
bool
Indicates if the environment variable should be passed to the external program. If true then the environment variable will be passed; otherwise, skipped. The default is true.
False
path
<path>
The value for a PATH like environment variable. You can use : or ; as path separators and NAnt will convert it to the platform's local conventions.
False
unless
bool
Indicates if the environment variable should not be passed to the external program. If false then the environment variable will be passed; otherwise, skipped. The default is false.
[This is preliminary documentation and subject to change.]
Moves a file, a directory, or set of files to a new file or directory.
Files are only moved if the source file is newer than the destination file, or if the destination file does not exist. However, you can explicitly overwrite files with the overwrite attribute.
Entire directory structures can be moved to a new location. For this to happen, the following criteria must be met:
Everything in the fileset is included
The directory structure is not flattened
Empty directories are included
Destination directory does not exist
If any of these items are not met, then the files within the source directory will be moved over instead of the entire directory structure.
A <fileset> can be used to select files or directories to move. To use a <fileset>, the todir attribute must be set.
Encoding
Unless an encoding is specified, the encoding associated with the system's current ANSI code page is used.
An UTF-8, little-endian Unicode, and big-endian Unicode encoded text file is automatically recognized, if the file starts with the appropriate byte order marks.
Note: If you employ filters in your move operation, you should limit the move to text files. Binary files will be corrupted by the move operation.
Parameters
Attribute
Type
Description
Required
file
file
The file to move.
False
flatten
bool
Ignore directory structure of source directory, move all files into a single directory, specified by the todir attribute. The default is false.
False
todir
directory
The directory to move to.
False
tofile
file
The file to move to.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
includeemptydirs
bool
Copy any empty directories included in the <fileset>. The default is true.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
False
Nested Elements:
<arg>
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Checks out a CVS module to the required directory.
Parameters
Attribute
Type
Description
Required
date
datetime
Specify the revision date to checkout. The date specified is validated and then passed to the cvs binary in a standard format recognized by cvs.
False
overridedir
string
Specify a directory name to replace the module name. Valid names include any valid filename, excluding path information.
False
override-directory
string
Specify a directory name to replace the module name. Valid names include any valid filename, excluding path information.
False
revision
string
Specify the revision to checkout. This corresponds to the "sticky-tag" of the file.
False
sticky-tag
string
Sticky tag or revision to checkout.
False
commandline
string
Command-line arguments for the program. The command line arguments are used to specify any cvs command options that are not available as attributes. These are appended after the command itself and are additive to whatever attributes are currently specified.
False
compressionlevel
int
Compression level to use for all net traffic. This should be a value from 1-9.
NOTE: This is not available on sharpcvslib.
False
cvsfullpath
file
The full path to the cvs binary used. The cvs tasks will attempt to "guess" the location of your cvs binary based on your path. If the task is unable to resolve the location, or resolves it incorrectly this can be used to manually specify the path.
False
cvsroot
string
The cvs root variable has the following components:
[protocol]:[username]@[servername]:[server path]
protocol: ext, pserver, ssh (sharpcvslib); if you are not using sharpcvslib consult your cvs documentation.
username: [username]
servername: cvs.sourceforge.net
server path: /cvsroot/nant
False
cvsrsh
file
The executable to use for ssh communication.
False
destination
directory
Destination directory for the local sandbox. If destination is not specified then the current directory is used.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
module
string
The module to perform an operation on.
False
passfile
file
The full path to the cached password file. If not specified then the environment variables are used to try and locate the file.
False
password
string
Deprecated. The password for logging in to the repository.
False
quiet
bool
Indicates if the output from the cvs command should be supressed. The default is false.
False
readonly
bool
true if the sandbox files should be checked out in read only mode. The default is false.
False
readwrite
bool
true if the sandbox files should be checked out in read/write mode. The default is true.
False
reallyquiet
bool
Indicates if the output from the cvs command should be stopped. The default is false.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
usesharpcvslib
bool
true if the SharpCvsLib binaries that come bundled with NAnt should be used to perform the cvs commands, false otherwise.
You may also specify an override value for all cvs tasks instead of specifying a value for each. To do this set the property sourcecontrol.usesharpcvslib to false.
If you choose not to use SharpCvsLib to checkout from cvs you will need to include a cvs.exe binary in your path.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
So the nant module tagged with revision 0_85 will be checked out in the folder v0.85 under the working/ destination directory. This could be used to work on different branches of a repository at the same time.
Checkout NAnt with specified revision date to the folder c:\src\nant\2003_08_16.
[This is preliminary documentation and subject to change.]
Executes a system command.
Use of nested arg element(s) is advised over the commandline parameter, as it supports automatic quoting and can resolve relative to absolute paths.
Parameters
Attribute
Type
Description
Required
program
string
The program to execute without command arguments.
True
append
bool
Gets or sets a value indicating whether output should be appended to the output file. The default is false.
False
basedir
directory
The directory the program is in.
False
commandline
string
The command-line arguments for the program. These will be passed as is to the external program. When quoting is necessary, these must be explictly set as part of the value. Consider using nested arg elements instead.
Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
False
output
file
The file to which the standard output will be redirected.
False
pidproperty
string
The name of a property in which the unique identifier of the spawned application should be stored. Only of interest if spawn is true.
False
resultproperty
string
The name of a property in which the exit code of the program should be stored. Only of interest if failonerror is false.
If the exit code of the program is "-1000" then the program could not be started, or did not exit (in time).
False
spawn
bool
Gets or sets a value indicating whether the application should be spawned. If you spawn an application, its output will not be logged by NAnt. The default is false.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program should be executed using a runtime engine, if configured. The default is false.
False
workingdir
directory
The directory in which the command will be executed.
False
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
timeout
int
The maximum amount of time the application is allowed to execute, expressed in milliseconds. Defaults to no time-out.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Framework-configurable parameters
Attribute
Type
Description
Required
exename
string
The name of the executable that should be used to launch the external program.
False
Nested Elements:
<environment>
Environment variables to pass to the program.
A set of environment variables.
Nested Elements:
<option>
Deprecated. Environment variable to pass to a program.
Represents an option.
Parameters
Attribute
Type
Description
Required
name
string
Name of the option.
True
if
bool
Indicates if the option should be passed to the task. If true then the option will be passed; otherwise, skipped. The default is true.
False
unless
bool
Indicates if the option should not be passed to the task. If false then the option will be passed; otherwise, skipped. The default is false.
False
value
string
Value of the option. The default is a null reference (Nothing in Visual Basic).
False
</option>
<variable>
Environment variable to pass to a program.
Represents an environment variable.
Parameters
Attribute
Type
Description
Required
name
string
The name of the environment variable.
True
dir
directory
The value for a directory-based environment variable. NAnt will convert it to an absolute path.
False
file
file
The value for a file-based environment variable. NAnt will convert it to an absolute filename.
False
if
bool
Indicates if the environment variable should be passed to the external program. If true then the environment variable will be passed; otherwise, skipped. The default is true.
False
path
<path>
The value for a PATH like environment variable. You can use : or ; as path separators and NAnt will convert it to the platform's local conventions.
False
unless
bool
Indicates if the environment variable should not be passed to the external program. If false then the environment variable will be passed; otherwise, skipped. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
Assuming the base directory of the build file is "c:\ikvm-test" and the value of the "fop.dist.dir" property is "c:\fop", then the value of the -cp argument that is passed toikvm.exe is "c:\ikvm-test\conf;c:\fop\build\fop.jar;conf;c:\fop\lib\xercesImpl-2.2.1.jar;c:\fop\lib\avalon-framework-cvs-20020806.jar;c:\fop\lib\batik.jar;c:\ikvm-test\lib\mylib.jar;c:\ikvm-test\lib\otherlib.zip" on a DOS-based system.
Specifies whether the external program should be treated as a managed application, possibly forcing it to be executed under the currently targeted version of the CLR.
False
useruntimeengine
bool
Deprecated. Specifies whether the external program is a managed application which should be executed using a runtime engine, if configured. The default is false.
The command-line arguments for the external program.
Represents a command-line argument.
When passed to an external application, the argument will be quoted when appropriate. This does not apply to the line parameter, which is always passed as is.
Parameters
Attribute
Type
Description
Required
dir
directory
The value for a directory-based command-line argument; will be replaced with the absolute path of the directory.
False
file
file
The name of a file as a single command-line argument; will be replaced with the absolute filename of the file.
False
if
bool
Indicates if the argument should be passed to the external program. If true then the argument will be passed; otherwise, skipped. The default is true.
False
line
string
List of command-line arguments; will be passed to the executable as is.
False
path
<path>
The value for a PATH-like command-line argument; you can use : or ; as path separators and NAnt will convert it to the platform's local conventions, while resolving references to environment variables.
False
unless
bool
Indicates if the argument should not be passed to the external program. If false then the argument will be passed; otherwise, skipped. The default is false.
False
value
string
A single command-line argument; can contain space characters.
[This is preliminary documentation and subject to change.]
Executes a set of tasks, and optionally catches a build exception to allow recovery or rollback steps to be taken, or to define some steps to be taken regardless if the tasks succeed or fail, or both.
The tasks defined in the <try> block will be executed in turn, as they normally would in a target.
If a <catch> block is defined, the tasks in that block will be executed in turn only if one of the tasks in the <try> block fails. This failure will then be suppressed by the <catch> block.
The message associated with the failure can also be caught in a property for use within the <catch> block. The original contents of the property will be restored upon exiting the <catch> block.
If a <finally> block is defined, the tasks in that block will be executed after the tasks in both the <try> and <catch> blocks have been executed, regardless of whether any task fails in either block.
Parameters
Attribute
Type
Description
Required
failonerror
bool
Determines if task failure stops the build, or is just reported. The default is true.
False
if
bool
If true then the task will be executed; otherwise, skipped. The default is true.
False
unless
bool
Opposite of if. If false then the task will be executed; otherwise, skipped. The default is false.
False
verbose
bool
Determines whether the task should report detailed build log messages. The default is false.
False
Nested Elements:
<try>
The tasks in this block will be executed as a normal part of the build script.
Executes embedded tasks/elements in the order in which they are defined.
</try>
<catch>
The tasks in this block will be executed if any task in the try block fails.
Parameters
Attribute
Type
Description
Required
property
string
Defines the name of the property to save the message describing the failure that has been caught.
False
</catch>
<finally>
The tasks in this block will always be executed, regardless of what happens in the try and catch blocks.
Executes embedded tasks/elements in the order in which they are defined.
In try
Caught failure: Just because...
Finally done
Build failed: Bad catch
Like the above, the failure in the <try> block does not cause the build to fail. The failure in the <catch> block does, however. Note that the <finally> block is executed even though the <catch> block failed.
In try
Caught failure yet again
Build failed: Property 'failure' has not been set.
The <echo> task in the <finally> block failed because the "failure" property was not defined after exiting the <catch> block. Note that the failure in the <finally> block has eclipsed the failure in the <catch> block.
[This is preliminary documentation and subject to change.]
Gets the name of the target that will be executed when no other build targets are specified.
Usage
string project::get-default-target()
Return Value
The name of the target that will be executed when no other build targets are specified, or an empty String if no default target is defined for the project.
The number of characters in the resulting string, equal to the number of original characters plus any additional padding characters.
paddingChar
string
A Unicode padding character.
Return Value
If the length of s is at least totalWidth, then a new String identical to s is returned. Otherwise, s will be padded on the left with as many paddingChar characters as needed to create a length of totalWidth.
Exceptions
The function will fail in any of the following circumstances:
totalWidth is less than zero.
Remarks
Note that only the first character of paddingChar will be used when padding the result.
The function will fail in any of the following circumstances:
assemblyString is a a null reference (Nothing in Visual Basic).
assemblyString is not found.
Examples
Determine the location of the Microsoft Access 11 Primary Interop Assembly by loading it using its fully qualified name, and copy it to the build directory.
The string representation of value, consisting of a negative sign if the value is negative, and a sequence of digits ranging from 0 to 9 with no leading zeroes.
Remarks
value is formatted with the NumberFormatInfo for the invariant culture.
The number of characters in the resulting string, equal to the number of original characters plus any additional padding characters.
paddingChar
string
A Unicode padding character.
Return Value
If the length of s is at least totalWidth, then a new String identical to s is returned. Otherwise, s will be padded on the right with as many paddingChar characters as needed to create a length of totalWidth.
Exceptions
The function will fail in any of the following circumstances:
totalWidth is less than zero.
Remarks
Note that only the first character of paddingChar will be used when padding the result.
The string representation of value, consisting of a negative sign if the value is negative, and a sequence of digits ranging from 0 to 9 with no leading zeroes.
Remarks
value is formatted with the NumberFormatInfo for the invariant culture.
[This is preliminary documentation and subject to change.]
Changes the extension of the path string.
Usage
string path::change-extension(path, extension)
Parameters
Name
Type
Description
path
string
The path information to modify. The path cannot contain any of the characters defined in InvalidPathCharsInvalidPathChars.
extension
string
The new extension (with a leading period). Specify a null reference to remove an existing extension from path.
Return Value
A string containing the modified path information.
On Windows-based desktop platforms, if path is an empty String, the path information is returned unmodified. If path has no extension, the returned path String contains extension appended to the end of path.
Exceptions
The function will fail in any of the following circumstances:
[This is preliminary documentation and subject to change.]
Determines whether a path string includes an extension.
Usage
bool path::has-extension(path)
Parameters
Name
Type
Description
path
string
The path to search for an extension.
Return Value
true. if the characters that follow the last directory separator or volume separator in the path include a period (.) followed by one or more characters; otherwise, false.
Exceptions
The function will fail in any of the following circumstances:
[This is preliminary documentation and subject to change.]
Combines two paths.
Usage
string path::combine(path1, path2)
Parameters
Name
Type
Description
path1
string
first path
path2
string
second path
Return Value
A string containing the combined paths. If one of the specified paths is a zero-length string, this method returns the other path. If path2 contains an absolute path, this method returns path2.
Exceptions
The function will fail in any of the following circumstances:
path1 or path2 contain one or more invalid characters.
///
/// The assembly references that are specified will be used to compile
/// the script, and will be loaded into the NAnt appdomain.
///
///
/// By default, only the NAnt.Core and mscorlib assemblies
/// are referenced.
///
///
///
/// Run C# code that writes a message to the build log.
///
/// <script language="C#">
/// <code>
/// <![CDATA[
/// public static void ScriptMain(Project project) {
/// project.Log(Level.Info, "Hello World from a script task using C#");
/// }
/// ]]>
/// </code>
/// </script>
///
///
///
/// Define a custom function and call it using C#.
///
/// <script language="C#" prefix="test" >
/// <code>
/// <![CDATA[
/// [Function("test-func")]
/// public static string Testfunc( ) {
/// return "some result !!!!!!!!";
/// }
/// ]]>
/// </code>
/// </script>
/// <echo message='${test::test-func()}'/>
///
///
///
/// Use a custom namespace in C# to create a database
///
/// <script language="C#" >
/// <references>
/// <include name="System.Data.dll" />
/// </references>
/// <imports>
/// <import namespace="System.Data.SqlClient" />
/// </imports>
/// <code>
/// <![CDATA[
/// public static void ScriptMain(Project project) {
/// string dbUserName = "nant";
/// string dbPassword = "nant";
/// string dbServer = "(local)";
/// string dbDatabaseName = "NAntSample";
/// string connectionString = String.Format("Server={0};uid={1};pwd={2};", dbServer, dbUserName, dbPassword);
///
/// SqlConnection connection = new SqlConnection(connectionString);
/// string createDbQuery = "CREATE DATABASE " + dbDatabaseName;
/// SqlCommand createDatabaseCommand = new SqlCommand(createDbQuery);
/// createDatabaseCommand.Connection = connection;
///
/// connection.Open();
///
/// try {
/// createDatabaseCommand.ExecuteNonQuery();
/// project.Log(Level.Info, "Database added successfully: " + dbDatabaseName);
/// } catch (Exception e) {
/// project.Log(Level.Error, e.ToString());
/// } finally {
/// connection.Close();
/// }
/// }
/// ]]>
/// </code>
/// </script>
///
///
///
///
/// Run Visual Basic.NET code that writes a message to the build log.
///
///
/// <script language="VB">
/// <code>
/// <![CDATA[
/// Public Shared Sub ScriptMain(project As Project)
/// project.Log(Level.Info, "Hello World from a script task using Visual Basic.NET")
/// End Sub
/// ]]>
/// </code>
/// </script>
///
///
///
/// Define a custom task and call it using C#.
///
/// <script language="C#" prefix="test" >
/// <code>
/// <![CDATA[
/// [TaskName("usertask")]
/// public class TestTask : Task {
/// #region Private Instance Fields
///
/// private string _message;
///
/// #endregion Private Instance Fields
///
/// #region Public Instance Properties
///
/// [TaskAttribute("message", Required=true)]
/// public string FileName {
/// get { return _message; }
/// set { _message = value; }
/// }
///
/// #endregion Public Instance Properties
///
/// #region Override implementation of Task
///
/// protected override void ExecuteTask() {
/// Log(Level.Info, _message.ToUpper());
/// }
/// #endregion Override implementation of Task
/// }
/// ]]>
/// </code>
/// </script>
/// <usertask message='Hello from UserTask'/>
///
///
///
///
/// Define a custom function and call it using Boo.
///
///
/// <script language="Boo.CodeDom.BooCodeProvider, Boo.CodeDom, Version=1.0.0.0, Culture=neutral, PublicKeyToken=32c39770e9a21a67"
/// failonerror="true">
/// <code>
/// <![CDATA[
///
/// [Function("test-func")]
/// def MyFunc():
/// return "Hello from Boo !!!!!!"
/// ]]>
/// </code>
/// </script>
/// <echo message='${script::test-func()}'/>
///
///
[TaskName("script")]
public class ScriptTask : Task {
#region Private Instance Fields
private string _language = null;
private AssemblyFileSet _references = new AssemblyFileSet();
private string _mainClass = "";
private string _rootClassName;
private string _prefix = "script";
private NamespaceImportCollection _imports = new NamespaceImportCollection();
private RawXml _code;
#endregion Private Instance Fields
#region Private Static Fields
private static readonly string[] _defaultNamespaces = {
"System",
"System.Collections",
"System.IO",
"System.Text",
"NAnt.Core",
"NAnt.Core.Attributes"};
#endregion Private Static Fields
#region Public Instance Properties
///
/// The language of the script block. Possible values are "VB", "vb", "VISUALBASIC", "C#", "c#", "CSHARP".
/// "JS", "js", "JSCRIPT" "VJS", "vjs", "JSHARP" or a fully-qualified name for a class implementing
/// .
///
[TaskAttribute("language", Required=true)]
public string Language {
get { return _language; }
set { _language = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Any required references.
///
[BuildElement("references")]
public AssemblyFileSet References {
get { return _references; }
set { _references = value; }
}
///
/// The name of the main class containing the static ScriptMain
/// entry point.
///
[TaskAttribute("mainclass", Required=false)]
public string MainClass {
get { return _mainClass; }
set { _mainClass = StringUtils.ConvertEmptyToNull(value); }
}
///
/// The namespace prefix for any custom functions defined in the script.
/// If ommitted the prefix will default to 'script'
///
[TaskAttribute("prefix", Required=false)]
public string Prefix {
get { return _prefix; }
set { _prefix = StringUtils.ConvertEmptyToNull(value); }
}
///
/// The namespaces to import.
///
[BuildElement("imports")]
public NamespaceImportCollection Imports {
get { return _imports; }
set { _imports = value; }
}
///
/// The code to execute.
///
[BuildElement("code", Required=true)]
public RawXml Code {
get { return _code; }
set { _code = value; }
}
#endregion Public Instance Properties
#region Override implementation of Task
///
/// Initializes the task.
///
protected override void Initialize() {
_rootClassName = "nant" + Guid.NewGuid().ToString("N",
CultureInfo.InvariantCulture);
}
///
/// Executes the script block.
///
protected override void ExecuteTask() {
// create compiler info for user-specified language
CompilerInfo compilerInfo = CreateCompilerInfo(Language);
// ensure base directory is set, even if fileset was not initialized
// from XML
if (References.BaseDirectory == null) {
References.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
ICodeCompiler compiler = compilerInfo.Compiler;
CompilerParameters options = new CompilerParameters();
options.GenerateExecutable = false;
options.GenerateInMemory = true;
options.MainClass = MainClass;
// implicitly reference the NAnt.Core assembly
options.ReferencedAssemblies.Add (typeof (Project).Assembly.Location);
// Log the assembly being added to the CompilerParameters
Log(Level.Verbose, "Adding assembly {0}", typeof (Project).Assembly.GetName().Name);
// add (and load) assemblies specified by user
foreach (string assemblyFile in References.FileNames) {
try {
// load the assembly into current AppDomain to ensure it is
// available when executing the emitted assembly
Assembly asm = Assembly.LoadFrom(assemblyFile);
// Log the assembly being added to the CompilerParameters
Log(Level.Verbose, "Adding assembly {0}", asm.GetName().Name);
// add the location of the loaded assembly
if (!String.IsNullOrEmpty(asm.Location)) {
options.ReferencedAssemblies.Add(asm.Location);
}
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2028"), assemblyFile), Location, ex);
}
}
StringCollection imports = new StringCollection();
foreach (NamespaceImport import in Imports) {
if (import.IfDefined && !import.UnlessDefined) {
imports.Add(import.Namespace);
}
}
// generate the code
CodeCompileUnit compileUnit = compilerInfo.GenerateCode(_rootClassName,
Code.Xml.InnerText, imports, Prefix);
StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
compilerInfo.CodeGen.GenerateCodeFromCompileUnit(compileUnit, sw, null);
string code = sw.ToString();
Log(Level.Debug, ResourceUtils.GetString("String_GeneratedCodeLooksLike") + "\n{0}", code);
CompilerResults results = compiler.CompileAssemblyFromDom(options, compileUnit);
Assembly compiled = null;
if (results.Errors.Count > 0) {
string errors = ResourceUtils.GetString("NA2029") + Environment.NewLine;
foreach (CompilerError err in results.Errors) {
errors += err.ToString() + Environment.NewLine;
}
errors += code;
throw new BuildException(errors, Location);
} else {
compiled = results.CompiledAssembly;
}
// scan the new assembly for tasks, types and functions
// Its unlikely that tasks will be defined in buildfiles though.
bool extensionAssembly = TypeFactory.ScanAssembly(compiled, this);
string mainClass = _rootClassName;
if (!String.IsNullOrEmpty(MainClass)) {
mainClass += "+" + MainClass;
}
Type mainType = compiled.GetType(mainClass);
if (mainType == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2030"), mainClass), Location);
}
MethodInfo entry = mainType.GetMethod("ScriptMain");
// check for task or function definitions.
if (entry == null) {
if (!extensionAssembly) {
throw new BuildException(ResourceUtils.GetString("NA2031"), Location);
} else {
return; // no entry point so nothing to do here beyond loading task and function defs
}
}
if (!entry.IsStatic) {
throw new BuildException(ResourceUtils.GetString("NA2032"), Location);
}
ParameterInfo[] entryParams = entry.GetParameters();
if (entryParams.Length != 1) {
throw new BuildException(ResourceUtils.GetString("NA2033"), Location);
}
if (entryParams[0].ParameterType.FullName != typeof(Project).FullName) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2034"), entryParams[0].ParameterType.FullName,
typeof(Project).FullName), Location);
}
try {
// invoke Main method
entry.Invoke(null, new object[] {Project});
} catch (Exception ex) {
// this exception is not likely to tell us much, BUT the
// InnerException normally contains the runtime exception
// thrown by the executed script code.
throw new BuildException(ResourceUtils.GetString("NA2035"), Location,
ex.InnerException);
}
}
#endregion Override implementation of Task
#region Private Instance Methods
private CompilerInfo CreateCompilerInfo(string language) {
CodeDomProvider provider = null;
try {
switch (language) {
case "vb":
case "VB":
case "VISUALBASIC":
provider = CreateCodeDomProvider(
"Microsoft.VisualBasic.VBCodeProvider",
"System, Culture=neutral");
break;
case "c#":
case "C#":
case "CSHARP":
provider = CreateCodeDomProvider(
"Microsoft.CSharp.CSharpCodeProvider",
"System, Culture=neutral");
break;
case "js":
case "JS":
case "JSCRIPT":
provider = CreateCodeDomProvider(
"Microsoft.JScript.JScriptCodeProvider",
"Microsoft.JScript, Culture=neutral");
break;
case "vjs":
case "VJS":
case "JSHARP":
provider = CreateCodeDomProvider(
"Microsoft.VJSharp.VJSharpCodeProvider",
"VJSharpCodeProvider, Culture=neutral");
break;
default:
// if its not one of the above then it must be a fully
// qualified provider class name
provider = CreateCodeDomProvider(language);
break;
}
return new CompilerInfo(provider);
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2036"), language), Location, ex);
}
}
#endregion Private Instance Methods
#region Private Static Methods
private static CodeDomProvider CreateCodeDomProvider(string typeName, string assemblyName) {
Assembly providerAssembly = Assembly.LoadWithPartialName(assemblyName);
if (providerAssembly == null) {
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2037"), assemblyName));
}
Type providerType = providerAssembly.GetType(typeName, true, true);
return CreateCodeDomProvider(providerType);
}
private static CodeDomProvider CreateCodeDomProvider(string assemblyQualifiedTypeName) {
Type providerType = Type.GetType(assemblyQualifiedTypeName, true, true);
return CreateCodeDomProvider(providerType);
}
private static CodeDomProvider CreateCodeDomProvider(Type providerType) {
object provider = Activator.CreateInstance(providerType);
if (!(provider is CodeDomProvider)) {
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2038"), providerType.FullName));
}
return (CodeDomProvider) provider;
}
#endregion Private Static Methods
internal class CompilerInfo {
public readonly ICodeCompiler Compiler;
public readonly ICodeGenerator CodeGen;
public CompilerInfo(CodeDomProvider provider) {
Compiler = provider.CreateCompiler();
CodeGen = provider.CreateGenerator();
}
public CodeCompileUnit GenerateCode(string typeName, string codeBody,
StringCollection imports,
string prefix) {
CodeCompileUnit compileUnit = new CodeCompileUnit();
CodeTypeDeclaration typeDecl = new CodeTypeDeclaration(typeName);
typeDecl.IsClass = true;
typeDecl.TypeAttributes = TypeAttributes.Public;
// create constructor
CodeConstructor constructMember = new CodeConstructor();
constructMember.Attributes = MemberAttributes.Public;
constructMember.Parameters.Add(new CodeParameterDeclarationExpression("NAnt.Core.Project", "project"));
constructMember.Parameters.Add(new CodeParameterDeclarationExpression("NAnt.Core.PropertyDictionary", "propDict"));
constructMember.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("project"));
constructMember.BaseConstructorArgs.Add(new CodeVariableReferenceExpression ("propDict"));
typeDecl.Members.Add(constructMember);
typeDecl.BaseTypes.Add(typeof(FunctionSetBase));
// add FunctionSet attribute
CodeAttributeDeclaration attrDecl = new CodeAttributeDeclaration("FunctionSet");
attrDecl.Arguments.Add(new CodeAttributeArgument(
new CodeVariableReferenceExpression("\"" + prefix + "\"")));
attrDecl.Arguments.Add(new CodeAttributeArgument(
new CodeVariableReferenceExpression("\"" + prefix + "\"")));
typeDecl.CustomAttributes.Add(attrDecl);
// pump in the user specified code as a snippet
CodeSnippetTypeMember literalMember =
new CodeSnippetTypeMember(codeBody);
typeDecl.Members.Add( literalMember );
CodeNamespace nspace = new CodeNamespace();
//Add default imports
foreach (string nameSpace in ScriptTask._defaultNamespaces) {
nspace.Imports.Add(new CodeNamespaceImport(nameSpace));
}
foreach (string nameSpace in imports) {
nspace.Imports.Add(new CodeNamespaceImport(nameSpace));
}
compileUnit.Namespaces.Add( nspace );
nspace.Types.Add(typeDecl);
return compileUnit;
}
}
}
}
nant-0.92-rc1/src/NAnt.DotNet/Tasks/NDocTask.cs 0000644 0001750 0001750 00000050263 11757302273 020743 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Ian MacLean (ian_maclean@another.com)
// Giuseppe Greco (giuseppe.greco@agamura.com)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Text;
using System.Xml;
using NDoc.Core;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.DotNet.Types;
using System.Reflection;
namespace NAnt.DotNet.Tasks {
///
/// Runs NDoc V1.3.1 to create documentation.
///
///
///
/// See the NDoc home page for more
/// information.
///
///
/// By default, only the NDoc MSDN documenter ships as part of the NAnt
/// distribution. To make another NDoc documenter from the NDoc V1.3.1
/// distribution available to the , copy the
/// documenter assembly (and possible dependencies) to the "lib"
/// directory corresponding with the CLR you're running NAnt on
/// (eg. <nant root>/bin/lib/net/1.1).
///
///
///
///
/// Document two assemblies using the MSDN documenter. The namespaces are
/// documented in NamespaceSummary.xml.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// ]]>
///
/// Content of NamespaceSummary.xml :
///
///
///
/// The Foo.Bar namespace reinvents the wheel.
///
///
/// The Foo.Bar.Tests namespace ensures that the Foo.Bar namespace reinvents the wheel correctly.
///
///
/// ]]>
///
///
[TaskName("ndoc")]
public class NDocTask : Task {
#region Private Instance Fields
private XmlNodeList _docNodes;
private AssemblyFileSet _assemblies = new AssemblyFileSet();
private FileSet _summaries = new FileSet();
private RawXml _documenters;
private DirSet _referencePaths = new DirSet();
private string _hhcexe;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// The set of assemblies to document.
///
[BuildElement("assemblies", Required=true)]
public AssemblyFileSet Assemblies {
get { return _assemblies; }
set { _assemblies = value; }
}
///
/// The set of namespace summary files.
///
[BuildElement("summaries")]
public FileSet Summaries {
get { return _summaries; }
set { _summaries = value; }
}
///
/// Specifies the formats in which the documentation should be generated.
///
[BuildElement("documenters", Required=true)]
public RawXml Documenters {
get { return _documenters; }
set { _documenters = value; }
}
///
/// Collection of additional directories to search for referenced
/// assemblies.
///
[BuildElement("referencepaths")]
public DirSet ReferencePaths {
get { return _referencePaths; }
set { _referencePaths = value; }
}
#endregion Public Instance Properties
#region Override implementation of Task
///
/// Initializes the taks and verifies the parameters.
///
protected override void Initialize() {
// expand and store clone of the xml node
_docNodes = Documenters.Xml.Clone().SelectNodes("nant:documenter",
NamespaceManager);
ExpandPropertiesInNodes(_docNodes);
_hhcexe = ResolveHhcExe();
}
///
/// Generates an NDoc project and builds the documentation.
///
protected override void ExecuteTask() {
// ensure base directory is set, even if fileset was not initialized
// from XML
if (Assemblies.BaseDirectory == null) {
Assemblies.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (Summaries.BaseDirectory == null) {
Summaries.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (ReferencePaths.BaseDirectory == null) {
ReferencePaths.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
// Make sure there is at least one included assembly. This can't
// be done in the Initialize() method because the files might
// not have been built at startup time.
if (Assemblies.FileNames.Count == 0) {
throw new BuildException(ResourceUtils.GetString("NA2020"), Location);
}
// create NDoc Project
NDoc.Core.Project project = null;
try {
project = new NDoc.Core.Project();
} catch (Exception ex) {
throw new BuildException(ResourceUtils.GetString("NA2021"), Location, ex);
}
// set-up probe path, meaning list of directories where NDoc searches
// for documenters
// by default, NDoc scans the startup path of the app, so we do not
// need to add this explicitly
string privateBinPath = AppDomain.CurrentDomain.SetupInformation.PrivateBinPath;
if (privateBinPath != null) {
// have NDoc also probe for documenters in the privatebinpath
foreach (string relativePath in privateBinPath.Split(Path.PathSeparator)) {
project.AppendProbePath(Path.Combine(
AppDomain.CurrentDomain.BaseDirectory, relativePath));
}
}
// check for valid documenters (any other validation can be done by NDoc itself at project load time)
foreach (XmlNode node in _docNodes) {
//skip non-nant namespace elements and special elements like comments, pis, text, etc.
if (!(node.NodeType == XmlNodeType.Element) || !node.NamespaceURI.Equals(NamespaceManager.LookupNamespace("nant"))) {
continue;
}
string documenterName = node.Attributes["name"].Value;
CheckAndGetDocumenter(project, documenterName);
}
// write documenter project settings to temp file
string projectFileName = Path.GetTempFileName();
Log(Level.Verbose, ResourceUtils.GetString("String_WritingProjectSettings"), projectFileName);
XmlTextWriter writer = new XmlTextWriter(projectFileName, Encoding.UTF8);
writer.Formatting = Formatting.Indented;
writer.WriteStartDocument();
writer.WriteStartElement("project");
// write assemblies section
writer.WriteStartElement("assemblies");
foreach (string assemblyPath in Assemblies.FileNames) {
string docPath = Path.ChangeExtension(assemblyPath, ".xml");
writer.WriteStartElement("assembly");
writer.WriteAttributeString("location", assemblyPath);
if (File.Exists(docPath)) {
writer.WriteAttributeString("documentation", docPath);
}
writer.WriteEndElement();
}
writer.WriteEndElement();
// write summaries section
StringBuilder sb = new StringBuilder();
foreach (string summaryPath in Summaries.FileNames) {
// write out the namespace summary nodes
try {
XmlTextReader tr = new XmlTextReader(summaryPath);
tr.MoveToContent(); // skip XmlDeclaration and Processing Instructions
sb.Append(tr.ReadOuterXml());
tr.Close();
} catch (IOException ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2022"), summaryPath), Location, ex);
}
}
writer.WriteRaw(sb.ToString());
// write out the documenters section
writer.WriteStartElement("documenters");
foreach (XmlNode node in _docNodes) {
//skip non-nant namespace elements and special elements like comments, pis, text, etc.
if (!(node.NodeType == XmlNodeType.Element) || !node.NamespaceURI.Equals(NamespaceManager.LookupNamespace("nant"))) {
continue;
}
writer.WriteRaw(node.OuterXml);
}
writer.WriteEndElement();
// end project element
writer.WriteEndElement();
writer.Close();
try {
// read NDoc project file
Log(Level.Verbose, ResourceUtils.GetString("String_NDocProjectFile"),
Path.GetFullPath(projectFileName));
project.Read(projectFileName);
// add additional directories to search for referenced assemblies
if (ReferencePaths.DirectoryNames.Count > 0) {
foreach (string directory in ReferencePaths.DirectoryNames) {
project.ReferencePaths.Add(new ReferencePath(directory));
}
}
foreach (XmlNode node in _docNodes) {
//skip non-nant namespace elements and special elements like comments, pis, text, etc.
if (!(node.NodeType == XmlNodeType.Element) || !node.NamespaceURI.Equals(NamespaceManager.LookupNamespace("nant"))) {
continue;
}
string documenterName = node.Attributes["name"].Value;
IDocumenter documenter = CheckAndGetDocumenter(project, documenterName);
// hook up events for feedback during the build
documenter.DocBuildingStep += new DocBuildingEventHandler(OnDocBuildingStep);
documenter.DocBuildingProgress += new DocBuildingEventHandler(OnDocBuildingProgress);
// build documentation
documenter.Build(project);
}
} catch (Exception ex) {
throw new BuildException(ResourceUtils.GetString("NA2023"), Location, ex);
}
}
#endregion Override implementation of Task
#region Private Instance Methods
///
/// Represents the method that will be called to update the overall
/// percent complete value and the current step name.
///
/// The source of the event.
/// A that contains the event data.
private void OnDocBuildingStep(object sender, ProgressArgs e) {
Log(Level.Info, e.Status);
if (e.Progress == 25 && null != _hhcexe) {
// right before progress step 25 HtmlHelp object will be created in MSDN Documentor
// so we can set path to hhc.exe per reflection
// determined with ILSpy
SetHtmlHelpCompiler(sender, _hhcexe);
}
}
///
/// Represents the method that will be called to update the current
/// step's precent complete value.
///
/// The source of the event.
/// A that contains the event data.
private void OnDocBuildingProgress(object sender, ProgressArgs e) {
Log(Level.Verbose, e.Progress + ResourceUtils.GetString("String_PercentageComplete"));
}
///
/// Returns the documenter for the given project.
///
///
/// Documenter is not found.
///
///
/// is .
///
private IDocumenter CheckAndGetDocumenter(NDoc.Core.Project project, string documenterName){
IDocumenter documenter = null;
if (project == null) {
throw new ArgumentNullException("project");
}
StringCollection documenters = new StringCollection();
foreach (IDocumenter d in project.Documenters) {
documenters.Add(d.Name);
// ignore case when comparing documenter names
if (string.Compare(d.Name, documenterName, true, CultureInfo.InvariantCulture) == 0) {
documenter = (IDocumenter) d;
break;
}
}
// throw an exception if the documenter could not be found.
if (documenter == null) {
if (documenters.Count == 0) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2024"), documenterName), Location);
} else {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2025"), documenterName,
StringUtils.Join(", ", documenters)), Location);
}
}
return documenter;
}
///
/// Performs macro expansion for the given nodes.
///
/// for which expansion should be performed.
private void ExpandPropertiesInNodes(XmlNodeList nodes) {
foreach (XmlNode node in nodes) {
// do not process comment nodes, or entities and other internal element types.
if (node.NodeType == XmlNodeType.Element) {
ExpandPropertiesInNodes(node.ChildNodes);
foreach (XmlAttribute attr in node.Attributes) {
// use "this" keyword as workaround for Mono bug #71992
attr.Value = this.Project.ExpandProperties(attr.Value, Location);
}
// convert output directory to full path relative to project base directory
XmlNode outputDirProperty = (XmlNode) node.SelectSingleNode("property[@name='OutputDirectory']");
if (outputDirProperty != null) {
XmlAttribute valueAttribute = (XmlAttribute) outputDirProperty.Attributes.GetNamedItem("value");
if (valueAttribute != null) {
// use "this" keyword as workaround for Mono bug #71992
valueAttribute.Value = this.Project.GetFullPath(valueAttribute.Value);
}
}
}
}
}
///
/// Use Reflection to set HtmplHelp._htmlHelpCompiler private field for MSDN Documentor.
/// Ndoc could not handle 64bit installations and is not actively developed anymore.
///
/// Active documentor
/// Path to hhc.exe
private void SetHtmlHelpCompiler(object sender, string hhcexe) {
Log(Level.Debug, "Setting Html Help Compiler per reflection");
FieldInfo fi = sender.GetType().GetField("htmlHelp", BindingFlags.NonPublic | BindingFlags.Instance);
if (null == fi)
return;
Log(Level.Debug, "Found MSDNDocumenter.htmlHelp field");
object htmlHelp = fi.GetValue(sender);
FieldInfo hhc = fi.FieldType.GetField("_htmlHelpCompiler", BindingFlags.NonPublic | BindingFlags.Instance);
if (null == hhc)
return;
Log(Level.Debug, "Found HtmlHelp._htmlHelpCompiler field");
hhc.SetValue(htmlHelp, hhcexe);
Log(Level.Verbose, "Set Html Help Compiler to '{0}'", hhcexe);
}
///
/// Searches in %ProgramFiles(x86)%\HTML Help Workshop and %ProgramFiles%\HTML Help Workshop
/// for hhc.exe. If not found let ndoc msdn documentor search itself
///
/// the path to hhc.exe if found, null otherwise
private string ResolveHhcExe() {
StringCollection folders = new StringCollection();
string hhwx86 = Environment.GetEnvironmentVariable("ProgramFiles(x86)");
if (!String.IsNullOrEmpty(hhwx86)) {
folders.Add(Path.Combine(hhwx86, "HTML Help Workshop"));
}
string hhw = Environment.GetEnvironmentVariable("ProgramFiles");
if (!String.IsNullOrEmpty(hhw)) {
folders.Add(Path.Combine(hhw, "HTML Help Workshop"));
}
string[] searchFolders = new string[folders.Count];
for (int i = 0; i < folders.Count; i++) {
searchFolders[i] = folders[i];
}
return FileUtils.ResolveFile(searchFolders, "hhc.exe", false);
}
#endregion Private Instance Methods
}
}
nant-0.92-rc1/src/NAnt.DotNet/Tasks/JscTask.cs 0000644 0001750 0001750 00000034247 11757302273 020643 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Mike Krueger (mike@icsharpcode.net)
// Giuseppe Greco (giuseppe.greco@agamura.com)
using System;
using System.IO;
using System.Text.RegularExpressions;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Util;
using NAnt.DotNet.Types;
namespace NAnt.DotNet.Tasks {
///
/// Compiles JScript.NET programs.
///
///
/// Compile helloworld.js to helloworld.exe.
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("jsc")]
[ProgramLocation(LocationType.FrameworkDir)]
public class JscTask : CompilerBase {
#region Private Instance Fields
private bool _autoRef;
private bool _nostdlib;
private string _warningLevel;
private string _codepage;
private string _platform;
private bool _versionSafe;
// framework configuration settings
private bool _supportsPlatform;
#endregion Private Instance Fields
#region Private Static Fields
private static Regex _classNameRegex = new Regex(@"^((?/\*.*?(\*/|$))|[\s\.\{]+|class\s+(?\w+)|(?\w+))*");
private static Regex _namespaceRegex = new Regex(@"^((?/\*.*?(\*/|$))|[\s\.\{]+|namespace\s+(?(\w+(\.\w+)*)+)|(?\w+))*");
#endregion Private Static Fields
#region Public Instance Properties
///
/// Automatically references assemblies if they have the same name as
/// an imported namespace or as a type annotation when declaring a
/// variable. The default is .
///
///
///
/// Corresponds with the /autoref flag.
///
///
[TaskAttribute("autoref")]
[BooleanValidator()]
public bool AutoRef {
get { return _autoRef; }
set { _autoRef = value; }
}
///
/// Instructs the compiler not to import standard library, and changes
/// to . The default is
/// .
///
///
///
/// Corresponds with the /noconfig flag.
///
///
[TaskAttribute("nostdlib")]
[BooleanValidator()]
public bool NoStdLib {
get { return _nostdlib; }
set { _nostdlib = value; }
}
///
/// Specifies which platform version of common language runtime (CLR)
/// can run the output file.
///
///
/// The platform version of common language runtime (CLR) that can run
/// the output file.
///
///
///
/// Corresponds with the /platform flag.
///
///
[TaskAttribute("platform")]
public string Platform {
get { return _platform; }
set { _platform = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Causes the compiler to generate errors for implicit method
/// overrides. The default is .
///
///
///
/// Corresponds with the /versionsafe flag.
///
///
[TaskAttribute("versionsafe")]
[BooleanValidator()]
public bool VersionSafe {
get { return _versionSafe; }
set { _versionSafe = value; }
}
///
/// Specifies the warning level for the compiler to display. Valid
/// values are 0-4. The default is 4.
///
///
/// The warning level for the compiler to display.
///
///
///
/// Corresponds with the /warn flag.
///
///
[TaskAttribute("warninglevel")]
[Int32Validator(0, 4)]
public string WarningLevel {
get { return _warningLevel; }
set { _warningLevel = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Controls which warnings should be reported as errors.
///
///
/// Override to avoid exposing this to build authors, as the JScript.NET
/// compiler does not allow control over which warnings should be
/// reported as errors.
///
public override WarningAsError WarningAsError {
get { return base.WarningAsError; }
}
///
/// Specifies a comma-separated list of warnings that should be suppressed
/// by the compiler.
///
///
/// Override to avoid exposing this to build authors, as the JScript.NET
/// compiler does not support package references.
///
[Obsolete("Use the element instead.", false)]
public override string NoWarn {
get { return base.NoWarn; }
set { base.NoWarn = value; }
}
///
/// Specifies a list of warnings that you want the compiler to suppress.
///
///
/// Override to avoid exposing this to build authors, as the JScript.NET
/// compiler does not support suppressing warnings.
///
public override CompilerWarningCollection SuppressWarnings {
get { return base.SuppressWarnings; }
}
///
/// Specifies the code page to use for all source code files in the
/// compilation.
///
///
///
/// Corresponds with the /codepage flag.
///
///
[TaskAttribute("codepage")]
public string Codepage {
get { return _codepage; }
set { _codepage = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the key pair container used to strongname the assembly.
///
///
/// Override to avoid exposing this to build authors, as the JScript.NET
/// does not support this.
///
public override string KeyContainer {
get { return base.KeyContainer; }
set { base.KeyContainer = value; }
}
///
/// Specifies a strong name key file.
///
///
/// Override to avoid exposing this to build authors, as the JScript.NET
/// does not support this.
///
public override FileInfo KeyFile {
get { return base.KeyFile; }
set { base.KeyFile = value; }
}
///
/// Specifies whether to delay sign the assembly using only the public
/// portion of the strong name key.
///
///
/// Override to avoid exposing this to build authors, as the JScript.NET
/// does not support this.
///
public override DelaySign DelaySign {
get { return base.DelaySign; }
set { base.DelaySign = value; }
}
///
/// Indicates whether the compiler for a given target framework supports
/// the "keycontainer" option. The default is .
///
///
/// .
///
///
/// Override to avoid exposing this to build authors, as the JScript.NET
/// does not support this.
///
public override bool SupportsKeyContainer {
get { return false; }
set { }
}
///
/// Indicates whether the compiler for a given target framework supports
/// the "keyfile" option. The default is .
///
///
/// .
///
///
/// Override to avoid exposing this to build authors, as the JScript.NET
/// does not support this.
///
public override bool SupportsKeyFile {
get { return false; }
set { }
}
///
/// Indicates whether the compiler for a given target framework supports
/// the "delaysign" option. The default is .
///
///
/// .
///
///
/// Override to avoid exposing this to build authors, as the JScript.NET
/// does not support this.
///
public override bool SupportsDelaySign {
get { return false; }
set { }
}
///
/// Specifies whether the compiler for the active target framework
/// supports limiting the platform on which the compiled code can run.
/// The default is .
///
[FrameworkConfigurable("supportsplatform")]
public bool SupportsPlatform {
get { return _supportsPlatform; }
set { _supportsPlatform = value; }
}
#endregion Public Instance Properties
#region Override implementation of CompilerBase
///
/// Link the specified modules into this assembly.
///
///
/// Override to avoid exposing this to build authors, as the JScript.NET
/// compiler does not support linking modules.
///
public override AssemblyFileSet Modules {
get { return base.Modules; }
set { base.Modules = value; }
}
///
/// Writes module references to the specified .
///
/// The to which the module references should be written.
protected override void WriteModuleReferences(TextWriter writer) {
if (Modules.FileNames.Count > 0) {
Log(Level.Warning, ResourceUtils.GetString("String_JscDoesNotSupportLinkingModules"));
}
}
///
/// Writes the compiler options to the specified .
///
/// to which the compiler options should be written.
protected override void WriteOptions(TextWriter writer) {
if (Debug) {
WriteOption(writer, "debug");
WriteOption(writer, "define", "DEBUG");
WriteOption(writer, "define", "TRACE");
}
if (NoStdLib) {
WriteOption(writer, "nostdlib");
} else if (AutoRef) {
WriteOption(writer, "autoref");
}
if (WarningLevel != null) {
WriteOption(writer, "warn" , WarningLevel);
}
if (Codepage != null) {
WriteOption(writer, "codepage", Codepage);
}
// platform
if (Platform != null) {
if (SupportsPlatform) {
WriteOption(writer, "platform", Platform);
} else {
Log(Level.Warning, ResourceUtils.GetString("String_CompilerDoesNotSupportPlatform"),
Project.TargetFramework.Description);
}
}
if (VersionSafe) {
WriteOption(writer, "versionsafe");
}
// win32res
if (Win32Res != null) {
WriteOption (writer, "win32res", Win32Res.FullName);
}
}
///
/// Gets the file extension required by the current compiler.
///
///
/// For the JScript.NET compiler, the file extension is always js.
///
public override string Extension {
get { return "js"; }
}
///
/// Gets the class name regular expression for the language of the
/// current compiler.
///
///
/// Class name regular expression for the language of the current
/// compiler.
///
protected override Regex ClassNameRegex {
get { return _classNameRegex; }
}
///
/// Gets the namespace regular expression for the language of the
/// current compiler.
///
///
/// Namespace regular expression for the language of the current
/// compiler.
///
protected override Regex NamespaceRegex {
get { return _namespaceRegex; }
}
#endregion Override implementation of CompilerBase
}
}
nant-0.92-rc1/src/NAnt.DotNet/Tasks/VbcTask.cs 0000644 0001750 0001750 00000054460 11757302273 020635 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Gert Driesen (drieseng@users.sourceforge.net)
// Mike Krueger (mike@icsharpcode.net)
// Aaron A. Anderson (aaron@skypoint.com | aaron.anderson@farmcreditbank.com)
// Giuseppe Greco (giuseppe.greco@agamura.com)
using System;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.DotNet.Types;
namespace NAnt.DotNet.Tasks {
///
/// Compiles Visual Basic.NET programs.
///
///
///
/// In order to have generate manifest resource names
/// that match those generated by Microsoft Visual Studio.NET, the value of
/// the attribute of the <>
/// element should match the "Root namespace" of the VB.NET project, and the
/// value of the attribute
/// should be set to "".
///
///
///
/// Example build file using this task.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("vbc")]
[ProgramLocation(LocationType.FrameworkDir)]
public class VbcTask : CompilerBase {
#region Private Instance Fields
private string _baseAddress;
private DebugOutput _debugOutput = DebugOutput.None;
private FileInfo _docFile;
private bool _nostdlib;
private string _optionCompare;
private bool _optionExplicit;
private bool _optionStrict;
private bool _optionOptimize;
private bool _removeintchecks;
private string _rootNamespace;
private string _platform;
private NamespaceImportCollection _imports = new NamespaceImportCollection();
// framework configuration settings
private bool _supportsDocGeneration;
private bool _supportsNoStdLib;
private bool _supportsPlatform;
#endregion Private Instance Fields
#region Private Static Fields
private static Regex _classNameRegex = new Regex(@"^((?/\*.*?(\*/|$))|[\s\.]+|Class\s+(?\w+)|(?\w+))*");
private static Regex _namespaceRegex = new Regex(@"^((?/\*.*?(\*/|$))|[\s\.]+|Namespace\s+(?(\w+(\.\w+)*)+)|(?\w+))*");
#endregion Private Static Fields
#region Public Instance Properties
///
/// The preferred base address at which to load a DLL. The default base
/// address for a DLL is set by the .NET Framework common language
/// runtime.
///
///
/// The preferred base address at which to load a DLL.
///
///
/// This address must be specified as a hexadecimal number.
///
[TaskAttribute("baseaddress")]
public string BaseAddress {
get { return _baseAddress; }
set { _baseAddress = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the type of debugging information generated by the
/// compiler. The default is .
///
[TaskAttribute("debug")]
public DebugOutput DebugOutput {
get { return _debugOutput; }
set { _debugOutput = value; }
}
///
/// No longer expose this to build authors. Use
/// instead.
///
public override bool Debug {
get { return DebugOutput != DebugOutput.None; }
set { DebugOutput = DebugOutput.Enable; }
}
///
/// The name of the XML documentation file to generate. Only supported
/// when targeting .NET 2.0 (or higher).
///
///
///
/// Corresponds with the /doc: flag.
///
///
[TaskAttribute("doc")]
public FileInfo DocFile {
get { return _docFile; }
set { _docFile = value; }
}
///
/// Specifies whether the /imports option gets passed to the
/// compiler.
///
///
/// The value of this attribute is a string that contains one or more
/// namespaces separated by commas.
///
///
/// See the Microsoft.NET Framework SDK documentation for details.
///
/// Example of an imports attribute
///
///
[TaskAttribute("imports")]
[Obsolete("Use the element instead.", false)]
public string ImportsString {
set {
if (!String.IsNullOrEmpty(value)) {
string[] imports = value.Split(',');
foreach (string import in imports) {
Imports.Add(new NamespaceImport(import));
}
}
}
}
///
/// The namespaces to import.
///
[BuildElement("imports")]
public NamespaceImportCollection Imports {
get { return _imports; }
set { _imports = value; }
}
///
/// Instructs the compiler not to reference standard libraries
/// (system.dll and VBC.RSP). The default is .
/// Only supported when targeting .NET 2.0 (or higher).
///
///
///
/// Corresponds with the /nostdlib flag.
///
///
[FrameworkConfigurable("nostdlib")]
[TaskAttribute("nostdlib")]
[BooleanValidator()]
public bool NoStdLib {
get { return _nostdlib; }
set { _nostdlib = value; }
}
///
/// Specifies whether /optioncompare option gets passed to the
/// compiler.
///
///
/// text, binary, or an empty string. If the value is
/// or an empty string, the option will not be
/// passed to the compiler.
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("optioncompare")]
public string OptionCompare {
get { return _optionCompare; }
set { _optionCompare = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies whether the /optionexplicit option gets passed to
/// the compiler. The default is .
///
///
/// if the option should be passed to the compiler;
/// otherwise, .
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("optionexplicit")]
[BooleanValidator()]
public bool OptionExplicit {
get { return _optionExplicit; }
set { _optionExplicit = value; }
}
///
/// Specifies whether the /optimize option gets passed to the
/// compiler. The default is .
///
///
/// if the option should be passed to the compiler;
/// otherwise, .
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("optionoptimize")]
[BooleanValidator()]
public bool OptionOptimize {
get { return _optionOptimize; }
set { _optionOptimize = value; }
}
///
/// Specifies whether the /optionstrict option gets passed to
/// the compiler. The default is .
///
///
/// if the option should be passed to the compiler;
/// otherwise, .
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("optionstrict")]
[BooleanValidator()]
public bool OptionStrict {
get { return _optionStrict; }
set { _optionStrict = value; }
}
///
/// Specifies which platform version of common language runtime (CLR)
/// can run the output file.
///
///
/// The platform version of common language runtime (CLR) that can run
/// the output file.
///
///
///
/// Corresponds with the /platform flag.
///
///
[TaskAttribute("platform")]
public string Platform {
get { return _platform; }
set { _platform = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies whether the /removeintchecks option gets passed to
/// the compiler. The default is .
///
///
/// if the option should be passed to the compiler;
/// otherwise, .
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("removeintchecks")]
[BooleanValidator()]
public bool RemoveIntChecks {
get { return _removeintchecks; }
set { _removeintchecks = value; }
}
///
/// Specifies whether the /rootnamespace option gets passed to
/// the compiler.
///
///
/// The value of this attribute is a string that contains the root
/// namespace of the project.
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("rootnamespace")]
public string RootNamespace {
get { return _rootNamespace; }
set { _rootNamespace = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies whether the compiler for the active target framework
/// supports generation of XML Documentation file. The default is
/// .
///
[FrameworkConfigurable("supportsdocgeneration")]
public bool SupportsDocGeneration {
get { return _supportsDocGeneration; }
set { _supportsDocGeneration = value; }
}
///
/// Specifies whether the compiler for the active target framework
/// supports NOT referencing standard libraries (system.dll and VBC.RSP).
/// The default is .
///
[FrameworkConfigurable("supportsnostdlib")]
public bool SupportsNoStdLib {
get { return _supportsNoStdLib; }
set { _supportsNoStdLib = value; }
}
///
/// Specifies whether the compiler for the active target framework
/// supports limiting the platform on which the compiled code can run.
/// The default is .
///
[FrameworkConfigurable("supportsplatform")]
public bool SupportsPlatform {
get { return _supportsPlatform; }
set { _supportsPlatform = value; }
}
#endregion Public Instance Properties
#region Override implementation of CompilerBase
///
/// Finds the correct namespace/classname for a resource file from the
/// given dependent source file, and ensure the
/// is prefixed.
///
/// The file from which the resource linkage of the resource file should be determined.
/// The culture of the resource file for which the resource linkage should be determined.
///
/// The namespace/classname of the source file matching the resource or
/// if the dependent source file does not exist.
///
protected override ResourceLinkage GetResourceLinkage(string dependentFile, CultureInfo resourceCulture) {
// determine resource linkage from dependent file
ResourceLinkage resourceLinkage = base.GetResourceLinkage(dependentFile, resourceCulture);
// check if resource linkage could be determined at all
if (resourceLinkage != null) {
// for VB.NET, the root namespace always needs to be used
if (!String.IsNullOrEmpty(RootNamespace)) {
if (resourceLinkage.HasNamespaceName) {
resourceLinkage.NamespaceName = RootNamespace + "." + resourceLinkage.NamespaceName;
} else {
resourceLinkage.NamespaceName = RootNamespace;
}
}
}
return resourceLinkage;
}
///
/// Writes conditional compilation constants to the specified
/// .
///
/// The to which the conditional compilation constants should be written.
protected override void WriteConditionalCompilationConstants(TextWriter writer) {
if (Define != null) {
string[] constants = Define.Split(',');
foreach (string constant in constants) {
WriteOption(writer, "define", constant);
}
}
}
///
/// Writes the compiler options to the specified .
///
/// to which the compiler options should be written.
protected override void WriteOptions(TextWriter writer) {
// the base address for the DLL
if (BaseAddress != null) {
WriteOption(writer, "baseaddress", BaseAddress);
}
// XML documentation
if (DocFile != null) {
if (SupportsDocGeneration) {
WriteOption(writer, "doc", DocFile.FullName);
} else {
Log(Level.Warning, ResourceUtils.GetString("String_CompilerDoesNotSupportXmlDoc"),
Project.TargetFramework.Description);
}
}
if (NoStdLib) {
if (SupportsNoStdLib) {
WriteOption(writer, "nostdlib");
} else {
Log(Level.Warning, ResourceUtils.GetString("String_CompilerDoesNotSupportNoStdLib"),
Project.TargetFramework.Description);
}
}
// platform
if (Platform != null) {
if (SupportsPlatform) {
WriteOption(writer, "platform", Platform);
} else {
Log(Level.Warning, ResourceUtils.GetString("String_CompilerDoesNotSupportPlatform"),
Project.TargetFramework.Description);
}
}
// win32res
if (Win32Res != null) {
WriteOption (writer, "win32resource", Win32Res.FullName);
}
// handle debug builds.
switch (DebugOutput) {
case DebugOutput.None:
break;
case DebugOutput.Enable:
WriteOption(writer, "debug");
WriteOption(writer, "define", "DEBUG=True");
WriteOption(writer, "define", "TRACE=True");
break;
case DebugOutput.Full:
WriteOption(writer, "debug");
break;
case DebugOutput.PdbOnly:
WriteOption(writer, "debug", "pdbonly");
break;
default:
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2011"), DebugOutput), Location);
}
string imports = Imports.ToString();
if (!String.IsNullOrEmpty(imports)) {
WriteOption(writer, "imports", imports);
}
if (OptionCompare != null && OptionCompare.ToUpper(CultureInfo.InvariantCulture) != "FALSE") {
WriteOption(writer, "optioncompare", OptionCompare);
}
if (OptionExplicit) {
WriteOption(writer, "optionexplicit");
}
if (OptionStrict) {
WriteOption(writer, "optionstrict");
}
if (RemoveIntChecks) {
WriteOption(writer, "removeintchecks");
}
if (OptionOptimize) {
WriteOption(writer, "optimize");
}
if (RootNamespace != null) {
WriteOption(writer, "rootnamespace", RootNamespace);
}
if (Project.TargetFramework.Family == "netcf") {
WriteOption(writer, "netcf");
WriteOption(writer, "sdkpath", Project.TargetFramework.
FrameworkAssemblyDirectory.FullName);
}
}
///
/// Determines whether compilation is needed.
///
protected override bool NeedsCompiling() {
if (base.NeedsCompiling()) {
return true;
}
if (DocFile != null && SupportsDocGeneration) {
if (!DocFile.Exists) {
Log(Level.Verbose, ResourceUtils.GetString("String_DocFileDoesNotExist"),
DocFile.FullName);
return true;
}
}
return base.NeedsCompiling();
}
///
/// Gets the file extension required by the current compiler.
///
///
/// For the VB.NET compiler, the file extension is always vb.
///
public override string Extension {
get { return "vb"; }
}
///
/// Gets the class name regular expression for the language of the
/// current compiler.
///
///
/// Class name regular expression for the language of the current
/// compiler.
///
protected override Regex ClassNameRegex {
get { return _classNameRegex; }
}
///
/// Gets the namespace regular expression for the language of the
/// current compiler.
///
///
/// Namespace regular expression for the language of the current
/// compiler.
///
protected override Regex NamespaceRegex {
get { return _namespaceRegex; }
}
#endregion Override implementation of CompilerBase
}
}
nant-0.92-rc1/src/NAnt.DotNet/Tasks/LicenseTask.cs 0000644 0001750 0001750 00000072223 11757302273 021502 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (mmastrac@canada.com)
// Sascha Andres (sa@programmers-world.com)
// Gert Driesen (drieseng@users.sourceforge.net)
// Giuseppe Greco (giuseppe.greco@agamura.com)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.Remoting.Lifetime;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.DotNet.Types;
namespace NAnt.DotNet.Tasks {
///
/// Generates a .licence file from a .licx file.
///
///
///
/// If no output file is specified, the default filename is the name of the
/// target file with the extension .licenses appended.
///
///
///
///
/// Generate the file component.exe.licenses file from component.licx.
///
///
///
/// ]]>
///
///
[Serializable()]
[TaskName("license")]
[ProgramLocation(LocationType.FrameworkSdkDir)]
public class LicenseTask : ExternalProgramBase {
#region Private Instance Fields
private AssemblyFileSet _assemblies = new AssemblyFileSet();
private FileInfo _inputFile;
private FileInfo _outputFile;
private string _target;
private string _programFileName;
private DirectoryInfo _workingDirectory;
// framework configuration settings
private bool _supportsAssemblyReferences;
private bool _hasCommandLineCompiler = true;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Input file to process.
///
[TaskAttribute("input", Required=true)]
public FileInfo InputFile {
get { return _inputFile; }
set { _inputFile = value; }
}
///
/// Name of the license file to output.
///
[TaskAttribute("output", Required=false)]
public FileInfo OutputFile {
get { return _outputFile; }
set { _outputFile = value; }
}
///
/// Names of the references to scan for the licensed component.
///
[BuildElement("assemblies")]
public AssemblyFileSet Assemblies {
get { return _assemblies; }
set { _assemblies = value; }
}
///
/// Specifies the executable for which the .licenses file is generated.
///
[TaskAttribute("licensetarget", Required=false)]
[StringValidator(AllowEmpty=false)]
[Obsolete("Use the \"target\" attribute instead.", false)]
public string LicenseTarget {
get { return Target; }
set { Target = value; }
}
// TODO: we need to mark "target" as required after the release of
// NAnt 0.85
//
// We can't do this right now, as it would be a major breaking change
// (build authors still use "licensetarget" right now).
///
/// Specifies the executable for which the .licenses file is generated.
///
[TaskAttribute("target", Required=false)]
[StringValidator(AllowEmpty=false)]
public string Target {
get { return _target; }
set { _target = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Indicates whether assembly references are supported by the current
/// target framework. The default is .
///
///
/// Applies only to frameworks having a command line tool for compiling
/// licenses files.
///
[FrameworkConfigurable("supportsassemblyreferences")]
public bool SupportsAssemblyReferences {
get { return _supportsAssemblyReferences; }
set { _supportsAssemblyReferences = value; }
}
///
/// Indicates whether the current target framework has a command line
/// tool for compiling licenses files. The default is
/// .
///
[FrameworkConfigurable("hascommandlinecompiler")]
public bool HasCommandLineCompiler {
get { return _hasCommandLineCompiler; }
set { _hasCommandLineCompiler = value; }
}
#endregion Public Instance Properties
#region Override implementation of Task
///
/// Initializes the class.
///
protected override void Initialize() {
// check if target was specified
// TODO: remove this check after NAnt 0.85 as this should be handled
// by setting Required to "true"
if (Target == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2013"), Name), Location);
}
// check if input file exists
if (!InputFile.Exists) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2014"), InputFile.FullName),
Location);
}
}
#endregion Override implementation of Task
#region Override implementation of ExternalProgramBase
///
/// Gets the working directory for the application.
///
///
/// The working directory for the application.
///
public override DirectoryInfo BaseDirectory {
get {
if (_workingDirectory == null) {
return base.BaseDirectory;
}
return _workingDirectory;
}
set {
_workingDirectory = value;
}
}
///
/// The command-line arguments for the external program.
///
///
/// Override to avoid exposing these elements in build file.
///
public override ArgumentCollection Arguments {
get { return base.Arguments; }
}
///
/// Gets the command-line arguments for the external program.
///
///
/// The command-line arguments for the external program.
///
public override string ProgramArguments {
get { return string.Empty; }
}
///
/// Gets the filename of the external program to start.
///
///
/// The filename of the external program.
///
///
/// Override in derived classes to explicitly set the location of the
/// external tool.
///
public override string ProgramFileName {
get {
if (_programFileName == null) {
_programFileName = base.ProgramFileName;
}
return _programFileName;
}
}
///
/// Updates the of the specified
/// .
///
/// The of which the should be updated.
protected override void PrepareProcess(Process process) {
if (!SupportsAssemblyReferences) {
// create instance of Copy task
CopyTask ct = new CopyTask();
// inherit project from current task
ct.Project = Project;
// inherit namespace manager from current task
ct.NamespaceManager = NamespaceManager;
// parent is current task
ct.Parent = this;
// inherit verbose setting from license task
ct.Verbose = Verbose;
// only output warning messages or higher, unless we're running
// in verbose mode
if (!ct.Verbose) {
ct.Threshold = Level.Warning;
}
// make sure framework specific information is set
ct.InitializeTaskConfiguration();
// set parent of child elements
ct.CopyFileSet.Parent = ct;
// inherit project from solution task for child elements
ct.CopyFileSet.Project = ct.Project;
// inherit namespace manager from solution task
ct.CopyFileSet.NamespaceManager = ct.NamespaceManager;
// set base directory of fileset
ct.CopyFileSet.BaseDirectory = Assemblies.BaseDirectory;
// copy all files to base directory itself
ct.Flatten = true;
// copy referenced assemblies
foreach (string file in Assemblies.FileNames) {
ct.CopyFileSet.Includes.Add(file);
}
// copy command line tool to working directory
ct.CopyFileSet.Includes.Add(base.ProgramFileName);
// set destination directory
ct.ToDirectory = BaseDirectory;
// increment indentation level
ct.Project.Indent();
try {
// execute task
ct.Execute();
} finally {
// restore indentation level
ct.Project.Unindent();
}
// change program to execute the tool in working directory as
// that will allow this tool to resolve assembly references
// using assemblies stored in the same directory
_programFileName = Path.Combine(BaseDirectory.FullName,
Path.GetFileName(base.ProgramFileName));
// determine target directory
string targetDir = Path.GetDirectoryName(Path.Combine(
BaseDirectory.FullName, Target));
// ensure target directory exists
if (!String.IsNullOrEmpty(targetDir) && !Directory.Exists(targetDir)) {
Directory.CreateDirectory(targetDir);
}
} else {
foreach (string assembly in Assemblies.FileNames) {
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/i:\"{0}\"", assembly)));
}
}
// further delegate preparation to base class
base.PrepareProcess(process);
}
///
/// Generates the license file.
///
protected override void ExecuteTask() {
FileInfo licensesFile = null;
// ensure base directory is set, even if fileset was not initialized
// from XML
if (Assemblies.BaseDirectory == null) {
Assemblies.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
// get the output .licenses file
if (OutputFile == null) {
try {
licensesFile = new FileInfo(Project.GetFullPath(Target + ".licenses"));
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2015"), Target), Location, ex);
}
} else {
licensesFile = OutputFile;
}
// make sure the directory for the .licenses file exists
if (!licensesFile.Directory.Exists) {
licensesFile.Directory.Create();
}
// determine whether .licenses file need to be recompiled
if (!NeedsCompiling(licensesFile)) {
return;
}
Log(Level.Verbose, ResourceUtils.GetString("String_CompilingLicenseUsingTarget"),
InputFile.FullName, licensesFile.FullName, Target);
if (HasCommandLineCompiler) {
// the command line compiler does not allow us to specify the
// full path to the output file, so we have it create the licenses
// file in a temp directory, and copy it to its actual output
// location
// use a newly created temporary directory as working directory
BaseDirectory = FileUtils.GetTempDirectory();
try {
// set target assembly for generated licenses file
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/target:\"{0}\"", Target)));
// set input filename
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/complist:\"{0}\"", InputFile.FullName)));
// set output directory
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/outdir:\"{0}\"", BaseDirectory.FullName)));
// suppress display of startup banner
Arguments.Add(new Argument("/nologo"));
// adjust verbosity of tool if necessary
if (Verbose) {
Arguments.Add(new Argument("/v"));
}
// use command line tool to compile licenses file
base.ExecuteTask();
// delete any existing output file
if (File.Exists(licensesFile.FullName)) {
File.Delete(licensesFile.FullName);
}
// copy licenses file to output file (with overwrite)
File.Copy(Path.Combine(BaseDirectory.FullName, Target + ".licenses"),
licensesFile.FullName, true);
} finally {
// delete temporary directory and all files in it
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = Project;
deleteTask.Parent = this;
deleteTask.InitializeTaskConfiguration();
deleteTask.Directory = BaseDirectory;
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
} else {
// create new domain
#if (NET_4_0)
AppDomain newDomain = AppDomain.CreateDomain("LicenseGatheringDomain");
LicenseGatherer licenseGatherer = (LicenseGatherer)
newDomain.CreateInstanceAndUnwrap(typeof(LicenseGatherer).Assembly.FullName,
typeof(LicenseGatherer).FullName, false, BindingFlags.Public | BindingFlags.Instance,
null, new object[0], CultureInfo.InvariantCulture, new object[0]);
#else
AppDomain newDomain = AppDomain.CreateDomain("LicenseGatheringDomain",
AppDomain.CurrentDomain.Evidence);
LicenseGatherer licenseGatherer = (LicenseGatherer)
newDomain.CreateInstanceAndUnwrap(typeof(LicenseGatherer).Assembly.FullName,
typeof(LicenseGatherer).FullName, false, BindingFlags.Public | BindingFlags.Instance,
null, new object[0], CultureInfo.InvariantCulture, new object[0],
AppDomain.CurrentDomain.Evidence);
#endif
licenseGatherer.CreateLicenseFile(this, licensesFile.FullName);
// unload newly created domain
AppDomain.Unload(newDomain);
}
}
#endregion Override implementation of ExternalProgramBase
#region Private Instance Methods
///
/// Determines whether the .licenses file needs to be recompiled
/// or is uptodate.
///
/// The .licenses file.
///
/// if the .licenses file needs compiling;
/// otherwise, .
///
private bool NeedsCompiling(FileInfo licensesFile) {
if (!licensesFile.Exists) {
Log(Level.Verbose, ResourceUtils.GetString("String_OutputFileDoesNotExist"),
licensesFile.FullName);
return true;
}
// check if assembly references were updated
string fileName = FileSet.FindMoreRecentLastWriteTime(Assemblies.FileNames, licensesFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
// check if input file was updated
if (InputFile != null) {
fileName = FileSet.FindMoreRecentLastWriteTime(InputFile.FullName, licensesFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
}
// if we made it here then we don't have to recompile
return false;
}
#endregion Private Instance Methods
///
/// Responsible for reading the license and writing them to a license
/// file.
///
private class LicenseGatherer : MarshalByRefObject {
#region Override implementation of MarshalByRefObject
///
/// Obtains a lifetime service object to control the lifetime policy for
/// this instance.
///
///
/// An object of type used to control the lifetime
/// policy for this instance. This is the current lifetime service object
/// for this instance if one exists; otherwise, a new lifetime service
/// object initialized with a lease that will never time out.
///
public override Object InitializeLifetimeService() {
ILease lease = (ILease) base.InitializeLifetimeService();
if (lease.CurrentState == LeaseState.Initial) {
lease.InitialLeaseTime = TimeSpan.Zero;
}
return lease;
}
#endregion Override implementation of MarshalByRefObject
#region Public Instance Methods
///
/// Creates the whole license file.
///
/// The instance for which the license file should be created.
/// The .licenses file to create.
public void CreateLicenseFile(LicenseTask licenseTask, string licensesFile) {
ArrayList assemblies = new ArrayList();
// create assembly resolver
AssemblyResolver assemblyResolver = new AssemblyResolver(licenseTask);
// attach assembly resolver to the current domain
assemblyResolver.Attach();
licenseTask.Log(Level.Verbose, ResourceUtils.GetString("String_LoadingAssemblies"));
try {
// first, load all the assemblies so that we can search for the
// licensed component
foreach (string assemblyFileName in licenseTask.Assemblies.FileNames) {
Assembly assembly = Assembly.LoadFrom(assemblyFileName);
if (assembly != null) {
// output assembly filename to build log
licenseTask.Log(Level.Verbose, ResourceUtils.GetString("String_AssemblyLoaded"),
assemblyFileName);
// add assembly to list of loaded assemblies
assemblies.Add(assembly);
}
}
DesigntimeLicenseContext dlc = new DesigntimeLicenseContext();
LicenseManager.CurrentContext = dlc;
// read the input file
using (StreamReader sr = new StreamReader(licenseTask.InputFile.FullName)) {
Hashtable licenseTypes = new Hashtable();
licenseTask.Log(Level.Verbose, ResourceUtils.GetString("String_CreatingLicenses"));
while (true) {
string line = sr.ReadLine();
if (line == null) {
break;
}
line = line.Trim();
// Skip comments, empty lines and already processed assemblies
if (line.StartsWith("#") || line.Length == 0 || licenseTypes.Contains(line)) {
continue;
}
licenseTask.Log(Level.Verbose, line + ": ");
// Strip off the assembly name, if it exists
string typeName;
if (line.IndexOf(',') != -1) {
typeName = line.Split(',')[0];
} else {
typeName = line;
}
Type tp = null;
// try to locate the type in each assembly
foreach (Assembly assembly in assemblies) {
if (tp == null) {
tp = assembly.GetType(typeName, false, true);
}
if (tp != null) {
break;
}
}
if (tp == null) {
try {
// final attempt, assuming line contains
// assembly qualfied name
tp = Type.GetType(line, false, false);
} catch {
// ignore error, we'll report the load
// failure later
}
}
if (tp == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2016"), typeName), licenseTask.Location);
} else {
// add license type to list of processed license types
licenseTypes[line] = tp;
}
// ensure that we've got a licensed component
if (tp.GetCustomAttributes(typeof(LicenseProviderAttribute), true).Length == 0) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2017"), tp.FullName),
licenseTask.Location);
}
try {
LicenseManager.CreateWithContext(tp, dlc);
} catch (Exception ex) {
if (IsSerializable(ex)) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2018"), tp.FullName),
licenseTask.Location, ex);
}
// do not directly pass the exception as inner
// exception to BuildException as the exception
// is not serializable, so construct a new
// exception with message set to message of
// original exception
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2018"), tp.FullName),
licenseTask.Location, new Exception(ex.Message));
}
}
}
// overwrite the existing file, if it exists - is there a better way?
if (File.Exists(licensesFile)) {
File.SetAttributes(licensesFile, FileAttributes.Normal);
File.Delete(licensesFile);
}
// write out the license file, keyed to the appropriate output
// target filename
// this .license file will only be valid for this exe/dll
using (FileStream fs = new FileStream(licensesFile, FileMode.Create)) {
DesigntimeLicenseContextSerializer.Serialize(fs, licenseTask.Target, dlc);
licenseTask.Log(Level.Verbose, ResourceUtils.GetString("String_CreatedNewLicense"),
licensesFile);
}
dlc = null;
} catch (BuildException) {
// re-throw exception
throw;
} catch (Exception ex) {
if (IsSerializable(ex)) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2019"), licenseTask.InputFile.FullName),
licenseTask.Location, ex);
} else {
// do not directly pass the exception as inner exception to
// BuildException as the exception might not be serializable,
// so construct a
// new exception with message set to message of
// original exception
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2019"), licenseTask.InputFile.FullName),
licenseTask.Location, new Exception(ex.Message));
}
} finally {
// detach assembly resolver from the current domain
assemblyResolver.Detach();
}
}
#endregion Public Instance Methods
#region Private Instance Methods
///
/// Determines whether the given object is serializable in binary
/// format.
///
/// The object to check.
///
/// if is
/// serializable in binary format; otherwise, .
///
private bool IsSerializable(object value) {
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream stream = new MemoryStream();
try {
formatter.Serialize(stream, value);
return true;
} catch (SerializationException) {
return false;
} finally {
stream.Close();
}
}
#endregion Private Instance Methods
}
}
}
nant-0.92-rc1/src/NAnt.DotNet/Tasks/RegSvcsTask.cs 0000644 0001750 0001750 00000026156 11757302273 021500 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Arjen Poutsma (poutsma@yahoo.com)
// Giuseppe Greco (giuseppe.greco@agamura.com)
using System;
using System.Globalization;
using System.IO;
using System.Text;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
namespace NAnt.DotNet.Tasks {
///
/// Installs or removes .NET Services.
///
///
///
/// This tasks provides the same functionality as the regsvcs tool
/// provided in the .NET SDK.
///
///
/// It performs the following actions:
///
///
///
/// Loads and registers an assembly.
///
///
/// Generates, registers, and installs a type library into a specified COM+ application.
///
///
/// Configures services that are added programmatically to your class.
///
///
///
/// Refer to the .NET Services Installation Tool (Regsvcs.exe) for more information.
///
///
///
///
/// Adds all public classes contained in myTest.dll to a COM+
/// application and produces the myTest.tlb type library. If the
/// application already exists, it is overwritten.
///
///
///
/// ]]>
///
///
///
///
/// Adds all public classes contained in myTest.dll to myTargetApp
/// and produces the myTest.tlb type library. If the application already
/// exists, it is overwritten.
///
///
///
/// ]]>
///
///
///
///
/// Adds all public classes contained in myTest.dll to a COM+
/// application and produces the myTest.tlb type library. A new
/// application is always created.
///
///
///
/// ]]>
///
///
///
///
/// Uninstalls the COM+ application contained in myTest.dll.
///
///
///
/// ]]>
///
///
[TaskName("regsvcs")]
[ProgramLocation(LocationType.FrameworkDir)]
public class RegsvcsTask : ExternalProgramBase {
///
/// Defines the possible actions for a .NET Service.
///
public enum ActionType {
///
/// Finds or creates the target application.
///
FindOrCreate,
///
/// Creates the target application.
///
Create,
///
/// Uninstalls the target application.
///
Uninstall
}
#region Private Instance Fields
private StringBuilder _argumentBuilder = null;
private ActionType _action = ActionType.FindOrCreate;
private FileInfo _assemblyFile;
private string _applicationName;
private FileInfo _typeLibrary;
private bool _existingTlb = false;
private bool _existingApplication = false;
private bool _noreconfig = false;
private bool _componentsOnly = false;
private string _partitionName = null;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Defines the action to take with the assembly. The default is
/// .
///
[TaskAttribute("action")]
public ActionType Action {
get { return _action; }
set {
if (!Enum.IsDefined(typeof(ActionType), value)) {
throw new ArgumentException(string.Format(
CultureInfo.InvariantCulture, ResourceUtils.GetString("NA2002"),
value));
} else {
this._action = value;
}
}
}
///
/// The source assembly file.
///
///
/// The assembly must be signed with a strong name.
///
[TaskAttribute("assembly", Required=true)]
[StringValidator(AllowEmpty=false)]
public FileInfo AssemblyFile {
get { return _assemblyFile; }
set { _assemblyFile = value; }
}
///
/// Specifies the type library file to install.
///
[TaskAttribute("tlb")]
public FileInfo TypeLibrary {
get { return _typeLibrary; }
set { _typeLibrary = value; }
}
///
/// Uses an existing type library. The default is .
///
[TaskAttribute("existingtlb")]
[BooleanValidator()]
public bool ExistingTypeLibrary {
get { return _existingTlb; }
set { _existingTlb = value; }
}
///
/// Do not reconfigure an existing target application.
/// The default is .
///
[TaskAttribute("noreconfig")]
[BooleanValidator()]
public bool NoReconfig {
get { return _noreconfig; }
set {_noreconfig = value; }
}
///
/// Configures components only; ignores methods and interfaces.
/// The default is .
///
[TaskAttribute("componentsonly")]
[BooleanValidator()]
public bool ComponentsOnly {
get { return _componentsOnly; }
set { _componentsOnly = value; }
}
///
/// Expect an existing application. The default is .
///
[TaskAttribute("existingapp")]
[BooleanValidator()]
public bool ExistingApplication {
get { return _existingApplication; }
set { _existingApplication = value; }
}
///
/// Specifies the name of the COM+ application to either find or create.
///
[TaskAttribute("application")]
public string ApplicationName {
get { return _applicationName; }
set { _applicationName = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the name or id of the COM+ application to either find or
/// create.
///
[TaskAttribute("partition")]
public string PartitionName {
get { return _partitionName; }
set { _partitionName = StringUtils.ConvertEmptyToNull(value); }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Gets the command-line arguments for the external program.
///
///
/// The command-line arguments for the external program.
///
public override string ProgramArguments {
get {
if (_argumentBuilder != null) {
return _argumentBuilder.ToString();
} else {
return null;
}
}
}
///
/// Performs the specified action.
///
protected override void ExecuteTask() {
_argumentBuilder = new StringBuilder();
switch (Action) {
case ActionType.Create:
_argumentBuilder.Append("/c ");
Log(Level.Info, ResourceUtils.GetString("String_CreatingCOM+Application"),
AssemblyFile.FullName);
break;
case ActionType.FindOrCreate:
_argumentBuilder.Append("/fc ");
Log(Level.Info, ResourceUtils.GetString("String_FindingCOM+Application"),
AssemblyFile.FullName);
break;
case ActionType.Uninstall:
_argumentBuilder.Append("/u ");
Log(Level.Info, ResourceUtils.GetString("String_UninstallingCOM+Application"),
AssemblyFile.FullName);
break;
}
if (TypeLibrary != null) {
_argumentBuilder.AppendFormat("/tlb:\"{0}\" ", TypeLibrary.FullName);
}
if (ExistingTypeLibrary) {
_argumentBuilder.Append("/extlb ");
}
if (NoReconfig) {
_argumentBuilder.Append("/noreconfig ");
}
if (ComponentsOnly) {
_argumentBuilder.Append("/componly ");
}
if (ApplicationName != null) {
_argumentBuilder.AppendFormat("/appname:\"{0}\" ", ApplicationName);
}
if (ExistingApplication) {
_argumentBuilder.Append("/exapp ");
}
if (PartitionName != null) {
_argumentBuilder.AppendFormat("/parname:\"{0}\" ", PartitionName);
}
if (!Verbose) {
_argumentBuilder.Append("/quiet ");
}
// suppresses display of the sign-on banner
_argumentBuilder.Append("/nologo ");
// output the assembly name enclosed with quotes
_argumentBuilder.Append("\"" + AssemblyFile.FullName + "\"");
// call base class to do perform the actual call
base.ExecuteTask();
}
#endregion Override implementation of ExternalProgramBase
}
}
nant-0.92-rc1/src/NAnt.DotNet/Tasks/DelaySignTask.cs 0000644 0001750 0001750 00000012730 11757302273 021774 0 ustar jtaylor jtaylor // NAntContrib
// Copyright (C) 2003 David Waite
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Giuseppe Greco (giuseppe.greco@agamura.com)
using System.Globalization;
using System.IO;
using System.Text;
using NAnt.Core;
using NAnt.Core.Tasks;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.DotNet.Tasks;
namespace NAnt.DotNet.Tasks {
///
/// Signs delay-signed .NET Assemblies, or re-signs existing assemblies.
///
///
///
/// The delay-signing mechanism takes a fileset (named targets)
/// and either a attribute for a file containing the
/// public and private keys, or to name a key
/// container.
///
///
///
/// Sign partially-signed foo.dll with bar.snk.
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("delay-sign")]
[ProgramLocation(LocationType.FrameworkSdkDir)]
public class DelaySignTask : ExternalProgramBase {
#region Private Instance Fields
private FileSet _targets = new FileSet();
private FileInfo _keyFile;
private string _keyContainer;
private StringBuilder _argumentBuilder;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// List of assemblies/executables to sign.
///
[BuildElement("targets")]
public FileSet Targets {
get { return _targets; }
set { _targets = value; }
}
///
/// Specifies the filesystem path to the signing key.
///
[TaskAttribute("keyfile")]
public FileInfo KeyFile {
get { return _keyFile; }
set { _keyFile = value; }
}
///
/// Specifies the key container.
///
[TaskAttribute("keycontainer")]
public string KeyContainer {
get { return _keyContainer; }
set { _keyContainer = StringUtils.ConvertEmptyToNull(value); }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Gets the command line arguments for the external program.
///
///
/// The command line arguments for the external program.
///
public override string ProgramArguments {
get {
if (_argumentBuilder != null) {
return _argumentBuilder.ToString();
} else {
return null;
}
}
}
///
/// Converts a single file or group of files.
///
protected override void ExecuteTask() {
bool keyAvail = KeyFile != null;
bool containerAvail = KeyContainer != null;
string keyname = containerAvail ? KeyContainer : KeyFile.FullName;
// ensure base directory is set, even if fileset was not initialized
// from XML
if (Targets.BaseDirectory == null) {
Targets.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if ((keyAvail && containerAvail) || (! keyAvail && ! containerAvail)) {
throw new BuildException(ResourceUtils.GetString("NA2012"), Location);
}
Log(Level.Info, ResourceUtils.GetString("String_DelaySigningAssemblies"),
Targets.FileNames.Count);
foreach (string filename in Targets.FileNames) {
// Try to guess the buffer length
// Add 12 for "-R", maybe 'c' and "-q", and spaces/quotes.
_argumentBuilder = new StringBuilder(9 + filename.Length + keyname.Length);
if (!Verbose) {
_argumentBuilder.Append("-q ");
}
// indicate that we want to resign a previously signed or delay-signed assembly
_argumentBuilder.Append("-R");
if (containerAvail) {
_argumentBuilder.Append('c');
}
_argumentBuilder.Append(" \"").Append(filename).Append("\" \"");
_argumentBuilder.Append(keyname).Append('\"');
// call base class to do perform the actual call
base.ExecuteTask();
}
}
#endregion Override implementation of ExternalProgramBase
}
}
nant-0.92-rc1/src/NAnt.DotNet/Tasks/IlasmTask.cs 0000644 0001750 0001750 00000046412 11757302273 021166 0 ustar jtaylor jtaylor // IlasmTask.cs
//
// Giuseppe Greco
// Copyright (C) 2004 Agamura, Inc.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Giuseppe Greco (giuseppe.greco@agamura.com)
using System.IO;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
namespace NAnt.DotNet.Tasks {
///
/// Compiles ILASM programs.
///
///
///
/// Compiles helloworld.il to helloworld.exe.
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("ilasm")]
[ProgramLocation(LocationType.FrameworkDir)]
public class IlasmTask : ExternalProgramBase {
#region Private Instance Fields
private bool _clock;
private bool _debug;
private bool _error;
private bool _forceRebuild;
private bool _listing;
private int _alignment;
private int _base;
private int _flags;
private int _subsystem;
private string _target;
private string _keySource;
private FileInfo _keyFile;
private FileInfo _outputFile;
private FileInfo _resourceFile;
private FileSet _sources;
private string _options;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Specifies whether or not the compiler should measure and report
/// the compilation times.
///
///
/// if the compilation times should be
/// measured and reported; otherwise, . The
/// default is .
///
///
///
/// Corresponds to the /CLOCK flag.
///
///
[TaskAttribute("clock")]
[BooleanValidator()]
public bool Clock {
get { return _clock; }
set { _clock = value; }
}
///
/// Specifies whether or not the compiler should generate debug
/// information.
///
///
/// if debug information should be generated;
/// otherwise, . The default is
/// .
///
///
///
/// Corresponds to the /DEBUG flag.
///
///
[TaskAttribute("debug")]
[BooleanValidator()]
public bool Debug {
get { return _debug; }
set { _debug = value; }
}
///
/// Specifies whether or not the compiler should attempt to create a
/// PE file even if compilation errors have been reported.
///
///
/// if a PE file has to be created even if
/// compilation errors have been reported; otherwise,
/// . The default is .
///
///
///
/// Corresponds to the /ERROR flag.
///
///
[TaskAttribute("error")]
[BooleanValidator()]
public bool Error {
get { return _error; }
set { _error = value; }
}
///
/// Instructs NAnt to recompile the output file regardless of the file
/// timestamps.
///
///
/// if the output file should be recompiled
/// regardless of its timestamps; otherwise .
/// The default is .
///
[TaskAttribute("rebuild")]
[BooleanValidator()]
public bool ForceRebuild {
get { return _forceRebuild; }
set { _forceRebuild = value; }
}
///
/// Specifies whether or not the compiler should type a formatted
/// listing of the compilation result.
///
///
/// if a formatted listing of the compilation
/// result should be typed; otherwise, . The
/// default is .
///
///
///
/// Corresponds to the /LISTING flag.
///
///
[TaskAttribute("listing")]
[BooleanValidator()]
public bool Listing {
get { return _listing; }
set { _listing = value; }
}
///
/// Instructs the compiler to set the FileAlignment value in
/// the PE header.
///
///
/// An that represents the FileAlignment
/// value to set in the PE header. The value must be a power of 2, in
/// range from 512 to 65536.
///
///
///
/// Corresponds to the /ALIGNMENT flag.
///
///
[TaskAttribute("alignment")]
[Int32Validator()]
public int Alignment {
get { return _alignment; }
set { _alignment = value; }
}
///
/// Instructs the compiler to set the ImageBase value in
/// the PE header.
///
///
/// A that represents the ImageBase
/// value to set in the PE header.
///
///
///
/// Corresponds to the /BASE flag.
///
///
[TaskAttribute("base")]
[Int32Validator()]
public int Base {
get { return _base; }
set { _base = value; }
}
///
/// Instructs the compiler to set the Flags value in the CLR
/// header.
///
///
/// An that represents the Flags
/// value to set in the CLR header. The most frequently value are 1
/// (pre-IL code) and 2 (mixed code). The third bit indicating that
/// the PE file is strong signed, is ignored.
///
///
///
/// Corresponds to the /FLAGS flag.
///
///
[TaskAttribute("flags")]
[Int32Validator()]
public int Flags {
get { return _flags; }
set { _flags = value; }
}
///
/// Instructs the compiler to set the Subsystem value in the PE
/// header.
///
///
/// An that represents the Subsystem
/// value to set in the PE header. The most frequently value are 3
/// (console application) and 2 (GUI application).
///
///
///
/// Corresponds to the /SUBSYSTEM flag.
///
///
[TaskAttribute("subsystem")]
[Int32Validator()]
public int Subsystem {
get { return _subsystem; }
set { _subsystem = value; }
}
///
/// Specifies which output type should be generated.
///
///
/// A that contains the target type.
/// Possible values are dll and exe.
///
///
///
/// Corresponds to the /OUTPUT flag.
///
///
[TaskAttribute("target", Required=true)]
[StringValidator(AllowEmpty=false)]
public string Target {
get { return _target; }
set { _target = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Instructs the compiler to generate a strong signature of the PE
/// file.
///
///
/// A that contains the private
/// encryption key.
///
///
///
/// Corresponds to the /KEY=keysource]]>
/// flag.
///
///
[TaskAttribute("keysource")]
public string KeySource {
get { return _keySource; }
set { _keySource = value; }
}
///
/// Instructs the compiler to generate a strong signature of the PE
/// file.
///
///
/// A that represents the file
/// containing the private encryption key.
///
///
///
/// Corresponds to the /KEY=keyfile]]>
/// flag.
///
///
[TaskAttribute("keyfile")]
public FileInfo KeyFile {
get { return _keyFile; }
set { _keyFile = value; }
}
///
/// Specifies the name of the output file created by the compiler.
///
///
/// A that represents the name of
/// the output file.
///
///
///
/// Corresponds to the /OUTPUT flag.
///
///
[TaskAttribute("output", Required=true)]
public FileInfo OutputFile {
get { return _outputFile; }
set { _outputFile = value; }
}
///
/// Instructs the compiler to link the specified unmanaged resource
/// file into the resulting PE file.
///
///
/// A that represents the unmanaged
/// resource file to link.
///
///
///
/// Corresponds to the /RESOURCE flag.
///
///
[TaskAttribute("resourcefile")]
public FileInfo ResourceFile {
get { return _resourceFile; }
set { _resourceFile = value; }
}
///
/// Specifies the set of source files to compile.
///
///
/// A that represents the set
/// of source files to compile.
///
[BuildElement("sources", Required=true)]
public FileSet Sources {
get { return _sources; }
set { _sources = value; }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Gets the command-line arguments for the external program.
///
///
/// A that contains the command-line
/// arguments for the external program.
///
public override string ProgramArguments {
get { return _options; }
}
///
/// Compiles the sources.
///
protected override void ExecuteTask() {
if (NeedsCompiling()) {
//
// ensure base directory is set, even if fileset has not been
// initialized in build file
//
if (Sources.BaseDirectory == null) {
Sources.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
Log(Level.Info, ResourceUtils.GetString("String_CompilingFiles"),
Sources.FileNames.Count, OutputFile.FullName);
//
// set command-line arguments for the ILASM compiler
//
WriteOptions();
//
// call base class to do the work
//
base.ExecuteTask();
}
}
#endregion Override implementation of ExternalProgramBase
#region Private Instance Methods
///
/// Writes the compiler options.
///
private void WriteOptions() {
StringWriter writer = new StringWriter();
try {
//
// always suppress logo and copyright statements
//
WriteOption(writer, "NOLOGO");
//
// suppress reporting compilation progress
// unless Verbose is true
//
if (!Verbose) {
WriteOption(writer, "QUIET");
}
if (Clock) {
WriteOption(writer, "CLOCK");
}
if (Debug) {
WriteOption(writer, "DEBUG");
}
if (Error) {
WriteOption(writer, "ERROR");
}
if (Listing) {
WriteOption(writer, "LISTING");
}
if (Alignment > 0) {
WriteOption(writer, "ALIGNMENT", Alignment.ToString());
}
if (Base > 0) {
WriteOption(writer, "BASE", Base.ToString());
}
if (Flags > 0) {
WriteOption(writer, "FLAGS", Flags.ToString());
}
if (Subsystem > 0) {
WriteOption(writer, "SUBSYSTEM", Subsystem.ToString());
}
if (Target != null) {
WriteOption(writer, Target.ToUpper());
}
if (KeySource != null) {
WriteOption(writer, "KEY", "@" + KeySource);
}
if (KeyFile != null) {
WriteOption(writer, "KEY", KeyFile.FullName);
}
if (OutputFile != null) {
WriteOption(writer, "OUTPUT", OutputFile.FullName);
}
if (ResourceFile != null) {
WriteOption(writer, "RESOURCE", ResourceFile.FullName);
}
foreach (string fileName in Sources.FileNames) {
writer.Write(" \"" + fileName + "\" ");
}
_options = writer.ToString();
} finally {
//
// close the StringWriter and the underlying stream
//
writer.Close();
}
}
///
/// Writes an option using the default output format.
///
///
/// The to which the compiler options should
/// be written.
///
///
/// A that contains the name of the
/// option which should be passed to the compiler.
///
private void WriteOption(StringWriter writer, string name) {
writer.Write("/{0} ", name);
}
///
/// Writes an option and its value using the default output format.
///
///
/// The to which the compiler options should
/// be written.
///
///
/// A that contains the name of the
/// option which should be passed to the compiler.
///
///
/// A that contains the value of the
/// option which should be passed to the compiler.
///
private void WriteOption(StringWriter writer, string name, string arg) {
//
// always quote arguments
//
writer.Write("\"/{0}={1}\" ", name, arg);
}
///
/// Determines whether or not compilation is needed.
///
///
/// if compilation is needed; otherwise,
/// .
///
private bool NeedsCompiling() {
if (ForceRebuild) {
Log(Level.Verbose, ResourceUtils.GetString("String_RebuildAttributeSetToTrue"));
return true;
}
// check if output file exists
if (!OutputFile.Exists) {
Log(Level.Verbose, ResourceUtils.GetString("String_OutputFileDoesNotExist"),
OutputFile.FullName);
return true;
}
// check if sources have been updated
string fileName = FileSet.FindMoreRecentLastWriteTime(
Sources.FileNames, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
// check if unmanaged resources have been updated
if (ResourceFile != null) {
fileName = FileSet.FindMoreRecentLastWriteTime(
ResourceFile.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
}
// check if strong name signature has been updated
if (KeyFile != null) {
fileName = FileSet.FindMoreRecentLastWriteTime(
KeyFile.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
}
// compilation not needed
return false;
}
#endregion Private Instance Methods
}
}
nant-0.92-rc1/src/NAnt.DotNet/Tasks/CscTask.cs 0000644 0001750 0001750 00000043642 11757302273 020633 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Mike Krueger (mike@icsharpcode.net)
// Gert Driesen (drieseng@users.sourceforge.net)
// Ian MacLean (ian_maclean@another.com)
// Giuseppe Greco (giuseppe.greco@agamura.com)
using System;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.DotNet.Types;
namespace NAnt.DotNet.Tasks {
///
/// Compiles C# programs.
///
///
///
/// In order to have generate manifest resource names
/// that match those generated by Microsoft Visual Studio.NET, the value of
/// the attribute of the <>
/// element should match the "Default Namespace" of the C# project, and the
/// value of the attribute
/// should be set to "".
///
///
///
/// Compile a "HelloWorld" application, including embedded resources.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("csc")]
[ProgramLocation(LocationType.FrameworkDir)]
public class CscTask : CompilerBase {
#region Private Instance Fields
private DebugOutput _debugOutput = DebugOutput.None;
private FileInfo _docFile;
private int _fileAlign;
private bool _nostdlib;
private bool _noconfig;
private bool _checked;
private bool _unsafe;
private bool _optimize;
private string _warningLevel;
private string _codepage;
private string _baseAddress;
private string _platform;
private string _langVersion;
// framework configuration settings
private bool _supportsDocGeneration = true;
private bool _supportsPlatform;
private bool _supportsLangVersion;
#endregion Private Instance Fields
#region Private Static Fields
private static Regex _classNameRegex = new Regex(@"^((?/\*.*?(\*/|$))|[\s\.\{]+|class\s+(?\w+)|(?\w+))*");
private static Regex _namespaceRegex = new Regex(@"^((?/\*.*?(\*/|$))|[\s\.\{]+|namespace\s+(?(\w+(\.\w+)*)+)|(?\w+))*");
#endregion Private Static Fields
#region Public Instance Properties
///
/// The preferred base address at which to load a DLL. The default base
/// address for a DLL is set by the .NET Framework common language
/// runtime.
///
///
/// The preferred base address at which to load a DLL.
///
///
/// This address can be specified as a decimal, hexadecimal, or octal
/// number.
///
[TaskAttribute("baseaddress")]
public string BaseAddress {
get { return _baseAddress; }
set { _baseAddress = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the type of debugging information generated by the
/// compiler. The default is .
///
[TaskAttribute("debug")]
public DebugOutput DebugOutput {
get { return _debugOutput; }
set { _debugOutput = value; }
}
///
/// No longer expose this to build authors. Use
/// instead.
///
public override bool Debug {
get { return DebugOutput != DebugOutput.None; }
set { DebugOutput = DebugOutput.Enable; }
}
///
/// The name of the XML documentation file to generate.
///
///
///
/// Corresponds with the /doc: flag.
///
///
[TaskAttribute("doc")]
public FileInfo DocFile {
get { return _docFile; }
set { _docFile = value; }
}
///
/// Specifies the size of sections in the output file. Valid values are
/// 512, 1024, 2048, 4096, and 8192.
///
///
/// The size of sections in the output file.
///
[TaskAttribute("filealign")]
[Int32Validator(512, 8192)]
public int FileAlign {
get { return _fileAlign; }
set { _fileAlign = value; }
}
///
/// Instructs the compiler not to import mscorlib.dll. The default is
/// .
///
///
///
/// Corresponds with the /nostdlib[+|-] flag.
///
///
[FrameworkConfigurable("nostdlib")]
[TaskAttribute("nostdlib")]
[BooleanValidator()]
public bool NoStdLib {
get { return _nostdlib; }
set { _nostdlib = value; }
}
///
/// Instructs the compiler not to use implicit references to assemblies.
/// The default is .
///
///
///
/// Corresponds with the /noconfig flag.
///
///
[FrameworkConfigurable("noconfig")]
[TaskAttribute("noconfig")]
[BooleanValidator()]
public bool NoConfig {
get { return _noconfig; }
set { _noconfig = value; }
}
///
/// Specifies whether an integer arithmetic statement that is not in
/// the scope of the checked or unchecked keywords and
/// that results in a value outside the range of the data type should
/// cause a run-time exception. The default is .
///
///
///
/// Corresponds with the /checked[+|-] flag.
///
///
[TaskAttribute("checked")]
[BooleanValidator()]
public bool Checked {
get { return _checked; }
set { _checked = value; }
}
///
/// Instructs the compiler to allow code that uses the unsafe
/// keyword. The default is .
///
///
///
/// Corresponds with the /unsafe[+|-] flag.
///
///
[TaskAttribute("unsafe")]
[BooleanValidator()]
public bool Unsafe {
get { return _unsafe; }
set { _unsafe = value; }
}
///
/// Causes the compiler to only accept syntax that is included in a
/// given specification.
///
///
///
/// Corresponds with the /langversion flag.
///
///
[TaskAttribute("langversion")]
public string LangVersion {
get { return _langVersion; }
set { _langVersion = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies whether the compiler should perform optimizations to the
/// make output files smaller, faster, and more effecient. The default
/// is .
///
///
/// if the compiler should perform optimizations;
/// otherwise, .
///
///
///
/// Corresponds with the /optimize[+|-] flag.
///
///
[TaskAttribute("optimize")]
[BooleanValidator()]
public bool Optimize {
get { return _optimize; }
set { _optimize = value; }
}
///
/// Specifies which platform version of common language runtime (CLR)
/// can run the output file.
///
///
/// The platform version of common language runtime (CLR) that can run
/// the output file.
///
///
///
/// Corresponds with the /platform flag.
///
///
[TaskAttribute("platform")]
public string Platform {
get { return _platform; }
set { _platform = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the warning level for the compiler to display. Valid values
/// are 0-4. The default is 4.
///
///
/// The warning level for the compiler to display.
///
///
///
/// Corresponds with the /warn flag.
///
///
[TaskAttribute("warninglevel")]
[Int32Validator(0, 4)]
public string WarningLevel {
get { return _warningLevel; }
set { _warningLevel = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the code page to use for all source code files in the
/// compilation.
///
///
///
/// Corresponds with the /codepage flag.
///
///
[TaskAttribute("codepage")]
public string Codepage {
get { return _codepage; }
set { _codepage = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies whether the compiler for the active target framework
/// supports generation of XML Documentation file. The default is
/// .
///
[FrameworkConfigurable("supportsdocgeneration")]
public bool SupportsDocGeneration {
get { return _supportsDocGeneration; }
set { _supportsDocGeneration = value; }
}
///
/// Specifies whether the compiler for the active target framework
/// supports limiting the platform on which the compiled code can run.
/// The default is .
///
[FrameworkConfigurable("supportsplatform")]
public bool SupportsPlatform {
get { return _supportsPlatform; }
set { _supportsPlatform = value; }
}
///
/// Specifies whether the compiler for the active target framework
/// supports accepting only a specific language syntax.
/// The default is .
///
[FrameworkConfigurable("supportslangversion")]
public bool SupportsLangVersion {
get { return _supportsLangVersion; }
set { _supportsLangVersion = value; }
}
#endregion Public Instance Properties
#region Override implementation of CompilerBase
///
/// Writes the compiler options to the specified .
///
/// to which the compiler options should be written.
protected override void WriteOptions(TextWriter writer) {
// causes the compiler to specify the full path of the file in which
// an error was found
WriteOption(writer, "fullpaths");
// the base address for the DLL
if (BaseAddress != null) {
WriteOption(writer, "baseaddress", BaseAddress);
}
// XML documentation
if (DocFile != null) {
if (SupportsDocGeneration) {
WriteOption(writer, "doc", DocFile.FullName);
} else {
Log(Level.Warning, ResourceUtils.GetString("String_CompilerDoesNotSupportXmlDoc"),
Project.TargetFramework.Description);
}
}
// langversion
if (LangVersion != null) {
if (SupportsLangVersion) {
WriteOption(writer, "langversion", LangVersion);
} else {
Log(Level.Warning, ResourceUtils.GetString("String_CompilerDoesNotSupportLangVersion"),
Project.TargetFramework.Description);
}
}
// platform
if (Platform != null) {
if (SupportsPlatform) {
WriteOption(writer, "platform", Platform);
} else {
Log(Level.Warning, ResourceUtils.GetString("String_CompilerDoesNotSupportPlatform"),
Project.TargetFramework.Description);
}
}
// win32res
if (Win32Res != null) {
WriteOption (writer, "win32res", Win32Res.FullName);
}
// handle debug builds.
switch (DebugOutput) {
case DebugOutput.None:
break;
case DebugOutput.Enable:
WriteOption(writer, "debug");
WriteOption(writer, "define", "DEBUG");
WriteOption(writer, "define", "TRACE");
break;
case DebugOutput.Full:
WriteOption(writer, "debug");
break;
case DebugOutput.PdbOnly:
WriteOption(writer, "debug", "pdbonly");
break;
default:
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2011"), DebugOutput), Location);
}
if (FileAlign > 0) {
WriteOption(writer, "filealign", FileAlign.ToString(CultureInfo.InvariantCulture));
}
if (NoStdLib) {
WriteOption(writer, "nostdlib");
}
if (Checked) {
WriteOption(writer, "checked");
}
if (Unsafe) {
WriteOption(writer, "unsafe");
}
if (Optimize) {
WriteOption(writer, "optimize");
}
if (WarningLevel != null) {
WriteOption(writer, "warn", WarningLevel);
}
if (Codepage != null) {
WriteOption(writer, "codepage", Codepage);
}
if (NoConfig && !Arguments.Contains("/noconfig")) {
Arguments.Add(new Argument("/noconfig"));
}
}
///
/// Determines whether compilation is needed.
///
protected override bool NeedsCompiling() {
if (base.NeedsCompiling()) {
return true;
}
if (DocFile != null && SupportsDocGeneration) {
if (!DocFile.Exists) {
Log(Level.Verbose, ResourceUtils.GetString("String_DocFileDoesNotExist"),
DocFile.FullName);
return true;
}
}
return false;
}
///
/// Gets the file extension required by the current compiler.
///
///
/// For the C# compiler, the file extension is always cs.
///
public override string Extension {
get { return "cs"; }
}
///
/// Gets the class name regular expression for the language of the
/// current compiler.
///
///
/// Class name regular expression for the language of the current
/// compiler.
///
protected override Regex ClassNameRegex {
get { return _classNameRegex; }
}
///
/// Gets the namespace regular expression for the language of the current compiler.
///
///
/// Namespace regular expression for the language of the current
/// compiler.
///
protected override Regex NamespaceRegex {
get { return _namespaceRegex; }
}
#endregion Override implementation of CompilerBase
}
}
nant-0.92-rc1/src/NAnt.DotNet/Tasks/AssemblyInfoTask.cs 0000644 0001750 0001750 00000072435 11757302273 022520 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2002-2003 Gordon Weakliem
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gordon Weakliem (gweakliem@oddpost.com)
// Gert Driesen (drieseng@users.sourceforge.net)
// Ian MacLean (ian_maclean@another.com)
// Giuseppe Greco (giuseppe.greco@agamura.com)
using System;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.Remoting.Lifetime;
using System.Security.Cryptography;
using System.Text;
using System.Security;
using System.Security.Permissions;
using System.Security.Policy;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.DotNet.Types;
namespace NAnt.DotNet.Tasks {
///
/// Generates an AssemblyInfo file using the attributes given.
///
///
///
/// Create a C# AssemblyInfo file containing the specified assembly-level
/// attributes.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// ]]>
///
///
///
///
/// Create a C# AssemblyInfo file containing an attribute with multiple
/// named properties by setting the
/// attribute on the element to
/// .
///
///
///
///
///
///
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("asminfo")]
[Serializable()]
public class AssemblyInfoTask : Task {
#region Private Instance Fields
private FileInfo _output;
private CodeLanguage _language = CodeLanguage.CSharp;
private AssemblyAttributeCollection _attributes = new AssemblyAttributeCollection();
private NamespaceImportCollection _imports = new NamespaceImportCollection();
private AssemblyFileSet _references = new AssemblyFileSet();
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Name of the AssemblyInfo file to generate.
///
///
/// The name of the AssemblyInfo file to generate.
///
[TaskAttribute("output", Required=true)]
public FileInfo Output {
get { return _output; }
set { _output = value; }
}
///
/// The code language in which the AssemblyInfo file should be
/// generated.
///
[TaskAttribute("language", Required=true)]
[StringValidator(AllowEmpty=false)]
public CodeLanguage Language {
get { return _language; }
set {
if (!Enum.IsDefined(typeof(CodeLanguage), value)) {
throw new ArgumentException(string.Format(
CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2002"), value));
} else {
_language = value;
}
}
}
///
/// The assembly-level attributes to generate.
///
///
/// The assembly-level attributes to generate.
///
[BuildElementCollection("attributes", "attribute")]
public AssemblyAttributeCollection AssemblyAttributes {
get { return _attributes; }
}
///
/// The namespaces to import.
///
///
/// The namespaces to import.
///
[BuildElement("imports")]
public NamespaceImportCollection Imports {
get { return _imports; }
set { _imports = value; }
}
///
/// Assembly files used to locate the types of the specified attributes.
///
[BuildElement("references")]
public AssemblyFileSet References {
get { return _references; }
set { _references = value; }
}
#endregion Public Instance Properties
#region Override implementation of Task
///
/// Generates an AssemblyInfo file.
///
protected override void ExecuteTask() {
try {
StringCollection imports = new StringCollection();
foreach (NamespaceImport import in Imports) {
if (import.IfDefined && !import.UnlessDefined) {
imports.Add(import.Namespace);
}
}
// ensure base directory is set, even if fileset was not initialized
// from XML
if (References.BaseDirectory == null) {
References.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
// write out code to memory stream, so we can compare it later
// to what is already present (if necessary)
MemoryStream generatedAsmInfoStream = new MemoryStream();
using (StreamWriter writer = new StreamWriter(generatedAsmInfoStream, Encoding.Default)) {
// create new instance of CodeProviderInfo for specified CodeLanguage
CodeProvider codeProvider = new CodeProvider(this, Language);
// only generate imports here for C#, for VB we create the
// imports as part of the assembly attributes compile unit
if (Language == CodeLanguage.CSharp) {
// generate imports code
codeProvider.GenerateImportCode(imports, writer);
}
// generate code for assembly attributes
codeProvider.GenerateAssemblyAttributesCode(AssemblyAttributes,
imports, References.FileNames, writer);
// flush
writer.Flush();
// check whether generated source should be persisted
if (NeedsPersisting(generatedAsmInfoStream)) {
using (FileStream fs = new FileStream(Output.FullName, FileMode.Create, FileAccess.Write)) {
byte[] buffer = generatedAsmInfoStream.ToArray();
fs.Write(buffer, 0, buffer.Length);
fs.Flush();
fs.Close();
generatedAsmInfoStream.Close();
}
Log(Level.Info, ResourceUtils.GetString("String_GeneratedFile"),
Output.FullName);
} else {
Log(Level.Verbose, ResourceUtils.GetString("String_FileUpToDate"),
Output.FullName);
}
}
} catch (Exception ex) {
throw new BuildException(string.Format(
CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2004"), Output.FullName), Location, ex);
}
}
#endregion Override implementation of Task
#region Private Instance Methods
///
/// Determines whether the specified AssemblyInfo file in the given
/// needs to be persisted.
///
/// holding the newly generated AssemblyInfo source.
///
/// if the generated AssemblyInfo source needs
/// to be persisted; otherwise, .
///
private bool NeedsPersisting(Stream generatedAsmInfoStream) {
// if output file doesn't exist, the stream will always need to be
// persisted to the filesystem.
if (!Output.Exists) {
Log(Level.Verbose, ResourceUtils.GetString("String_OutputFileDoesNotExist"),
Output.FullName);
return true;
}
byte[] existingAssemblyInfoHash = null;
byte[] generatedAssemblyInfoHash = null;
SHA1 hasher = new SHA1CryptoServiceProvider();
// hash existing AssemblyInfo source
using (FileStream fs = new FileStream(Output.FullName, FileMode.Open, FileAccess.Read)) {
existingAssemblyInfoHash = hasher.ComputeHash(fs);
}
// hash generated AssemblyInfo source
generatedAsmInfoStream.Position = 0;
generatedAssemblyInfoHash = hasher.ComputeHash(generatedAsmInfoStream);
// release all resources
hasher.Clear();
//compare hash of generated source with of existing source
if (Convert.ToBase64String(generatedAssemblyInfoHash) != Convert.ToBase64String(existingAssemblyInfoHash)) {
Log(Level.Verbose, ResourceUtils.GetString("String_OutputFileNotUpToDate"),
Output.FullName);
return true;
} else {
return false;
}
}
#endregion Private Instance Methods
///
/// Defines the supported code languages for generating an AssemblyInfo
/// file.
///
public enum CodeLanguage : int {
///
/// A value for generating C# code.
///
CSharp = 0,
///
/// A value for generating JScript code.
///
JScript = 1,
///
/// A value for generating Visual Basic code.
///
VB = 2,
}
///
/// Encapsulates functionality to generate a code file with imports
/// and assembly-level attributes.
///
internal class CodeProvider {
#region Private Instance Fields
private readonly CodeLanguage _language;
private readonly ICodeGenerator _generator;
#endregion Private Instance Fields
#region Public Instance Constructors
///
/// Initializes a new instance of the
/// for the specified .
///
/// The for which an instance of the class should be initialized.
/// The for which an instance of the class should be initialized.
public CodeProvider(AssemblyInfoTask assemblyInfoTask, CodeLanguage codeLanguage) {
CodeDomProvider provider = null;
switch (codeLanguage) {
case CodeLanguage.CSharp:
provider = new Microsoft.CSharp.CSharpCodeProvider();
break;
case CodeLanguage.JScript:
throw new NotSupportedException(ResourceUtils.GetString("NA2008"));
case CodeLanguage.VB:
provider = new Microsoft.VisualBasic.VBCodeProvider();
break;
default:
throw new NotSupportedException(ResourceUtils.GetString("NA2007"));
}
_generator = provider.CreateGenerator();
_language = codeLanguage;
}
#endregion Public Instance Constructors
#region Private Instance Properties
///
/// Gets the in which the AssemblyInfo
/// code will be generated.
///
private CodeLanguage Language {
get { return _language; }
}
///
/// Gets the that will be used to
/// generate the AssemblyInfo code.
///
private ICodeGenerator Generator {
get { return _generator; }
}
#endregion Private Instance Properties
#region Public Instance Methods
///
/// Generates code for the specified imports.
///
/// The imports for which code should be generated.
/// The to which the generated code will be written.
public void GenerateImportCode(StringCollection imports, TextWriter writer) {
CodeNamespace codeNamespace = new CodeNamespace();
foreach (string import in imports) {
codeNamespace.Imports.Add(new CodeNamespaceImport(import));
}
Generator.GenerateCodeFromNamespace(codeNamespace, writer, new CodeGeneratorOptions());
}
///
/// Generates code for the specified assembly attributes.
///
/// The assembly attributes for which code should be generated.
/// Imports used to resolve the assembly attribute names to fully qualified type names.
/// Assembly that will be used to resolve the attribute names to instances.
/// The to which the generated code will be written.
public void GenerateAssemblyAttributesCode(AssemblyAttributeCollection assemblyAttributes, StringCollection imports, StringCollection assemblies, TextWriter writer) {
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
// for C# the imports were already generated, as the # generator
// will otherwise output the imports after the assembly attributes
if (Language == CodeLanguage.VB) {
CodeNamespace codeNamespace = new CodeNamespace();
foreach (string import in imports) {
codeNamespace.Imports.Add(new CodeNamespaceImport(import));
}
codeCompileUnit.Namespaces.Add(codeNamespace);
}
foreach (AssemblyAttribute assemblyAttribute in assemblyAttributes) {
if (assemblyAttribute.IfDefined && !assemblyAttribute.UnlessDefined) {
// create new assembly-level attribute
CodeAttributeDeclaration codeAttributeDeclaration = new CodeAttributeDeclaration(assemblyAttribute.TypeName);
if (assemblyAttribute.AsIs) {
codeAttributeDeclaration.Arguments.Add(new CodeAttributeArgument(new CodeSnippetExpression(assemblyAttribute.Value)));
} else {
// convert string value to type expected by attribute constructor
object typedValue = GetTypedValue(assemblyAttribute, assemblies, imports);
if (typedValue != null) {
// add typed value to attribute arguments
codeAttributeDeclaration.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(typedValue)));
}
}
// add assembly-level argument to code compile unit
codeCompileUnit.AssemblyCustomAttributes.Add(codeAttributeDeclaration);
}
}
Generator.GenerateCodeFromCompileUnit(codeCompileUnit, writer, new CodeGeneratorOptions());
}
#endregion Public Instance Methods
#region Private Instance Methods
private object GetTypedValue(AssemblyAttribute attribute, StringCollection assemblies, StringCollection imports) {
// locate type assuming TypeName is fully qualified typename
PermissionSet domainPermSet = new PermissionSet(PermissionState.Unrestricted);
AppDomain newDomain = AppDomain.CreateDomain("TypeGatheringDomain", AppDomain.CurrentDomain.Evidence,
AppDomain.CurrentDomain.SetupInformation, domainPermSet);
#if NET_4_0
TypedValueGatherer typedValueGatherer = (TypedValueGatherer)
newDomain.CreateInstanceAndUnwrap(typeof(TypedValueGatherer).Assembly.FullName,
typeof(TypedValueGatherer).FullName, false, BindingFlags.Public | BindingFlags.Instance,
null, new object[0], CultureInfo.InvariantCulture, new object[0]);
#else
TypedValueGatherer typedValueGatherer = (TypedValueGatherer)
newDomain.CreateInstanceAndUnwrap(typeof(TypedValueGatherer).Assembly.FullName,
typeof(TypedValueGatherer).FullName, false, BindingFlags.Public | BindingFlags.Instance,
null, new object[0], CultureInfo.InvariantCulture, new object[0],
AppDomain.CurrentDomain.Evidence);
#endif
object typedValue = typedValueGatherer.GetTypedValue(
assemblies, imports, attribute.TypeName, attribute.Value);
// unload newly created AppDomain
AppDomain.Unload(newDomain);
return typedValue;
}
#endregion Private Instance Methods
}
///
/// Responsible for returning the specified value converted to a
/// accepted by a constructor for a given
/// .
///
private class TypedValueGatherer : MarshalByRefObject {
#region Override implementation of MarshalByRefObject
///
/// Obtains a lifetime service object to control the lifetime policy for
/// this instance.
///
///
/// An object of type used to control the lifetime
/// policy for this instance. This is the current lifetime service object
/// for this instance if one exists; otherwise, a new lifetime service
/// object initialized with a lease that will never time out.
///
public override Object InitializeLifetimeService() {
ILease lease = (ILease) base.InitializeLifetimeService();
if (lease.CurrentState == LeaseState.Initial) {
lease.InitialLeaseTime = TimeSpan.Zero;
}
return lease;
}
#endregion Override implementation of MarshalByRefObject
#region Public Instance Methods
///
/// Retrieves the specified corresponding with the specified
/// type name from a list of assemblies.
///
/// The collection of assemblies that the type should tried to be instantiated from.
/// The list of imports that can be used to resolve the typename to a full typename.
/// The typename that should be used to determine the type to which the specified value should be converted.
/// The value that should be converted to a typed value.
///
///
/// is and the identified by has no default public constructor.
/// -or-
/// cannot be converted to a value that's suitable for one of the constructors of the identified by .
/// -or-
/// The identified by has no suitable constructor.
/// -or-
/// A identified by could not be located or loaded.
///
public object GetTypedValue(StringCollection assemblies, StringCollection imports, string typename, string value) {
// create assembly resolver
AssemblyResolver assemblyResolver = new AssemblyResolver();
// attach assembly resolver to the current domain
assemblyResolver.Attach();
try {
// Try to find the type from typename parameter.
Type type = FindType(assemblies, imports, typename);
if (type != null) {
object typedValue = null;
if (value == null) {
ConstructorInfo defaultConstructor = type.GetConstructor(
BindingFlags.Public | BindingFlags.Instance, null,
new Type[0], new ParameterModifier[0]);
if (defaultConstructor == null) {
throw new BuildException(string.Format(
CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2005"), type.FullName), Location.UnknownLocation);
}
typedValue = null;
} else {
ConstructorInfo[] constructors = type.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
for (int counter = 0; counter < constructors.Length; counter++) {
ParameterInfo[] parameters = constructors[counter].GetParameters();
if (parameters.Length == 1) {
if (parameters[0].ParameterType.IsPrimitive || parameters[0].ParameterType == typeof(string)) {
try {
// convert value to type of constructor parameter
typedValue = Convert.ChangeType(value, parameters[0].ParameterType, CultureInfo.InvariantCulture);
break;
} catch (Exception ex) {
throw new BuildException(string.Format(
CultureInfo.InvariantCulture, ResourceUtils.GetString("NA2006"),
value, parameters[0].ParameterType.FullName, type.FullName),
Location.UnknownLocation, ex);
}
}
}
}
if (typedValue == null) {
throw new BuildException(string.Format(
CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2003"), typename),
Location.UnknownLocation);
}
}
return typedValue;
} else {
if (!typename.EndsWith("Attribute"))
{
throw new BuildException(string.Format(
CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2039"),typename),
Location.UnknownLocation);
}
else
{
throw new BuildException(string.Format(
CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2001"),typename),
Location.UnknownLocation);
}
}
} finally {
// detach assembly resolver from the current domain
assemblyResolver.Detach();
}
}
#endregion Public Instance Methods
#region Private Instance Methods
///
/// Finds a given type from a given list of assemblies and import statements.
///
///
/// A list of assemblies to search for a given type.
///
///
/// A list of import statements to search for a given type.
///
///
/// The name of the type to locate.
///
///
/// The type object found from assemblies and import statements based
/// on the name of the type.
///
private Type FindType(StringCollection assemblies, StringCollection imports, string typename)
{
Type type = null;
// load each assembly and try to get type from it
foreach (string assemblyFileName in assemblies) {
// load assembly from filesystem
Assembly assembly = Assembly.LoadFrom(assemblyFileName);
// try to load type from assembly
type = assembly.GetType(typename, false, false);
if (type == null) {
foreach (string import in imports) {
type = assembly.GetType(import + "." + typename, false, false);
if (type != null) {
break;
}
}
}
if (type != null) {
break;
}
}
// try to load type from all assemblies loaded from disk, if
// it was not loaded from the references assemblies
if (type == null) {
type = Type.GetType(typename, false, false);
if (type == null) {
foreach (string import in imports) {
type = Type.GetType(import + "." + typename, false, false);
if (type != null) {
break;
}
}
}
}
return type;
}
#endregion Private Instance Methods
}
}
}
nant-0.92-rc1/src/NAnt.DotNet/Tasks/VjcTask.cs 0000644 0001750 0001750 00000037034 11757302273 020643 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Tom Jordan (tdjordan@users.sourceforge.net)
// Giuseppe Greco (giuseppe.greco@agamura.com)
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Util;
using NAnt.DotNet.Types;
namespace NAnt.DotNet.Tasks {
///
/// Compiles Visual J# programs using vjc, Microsoft's J# compiler.
///
///
///
/// In order to have generate manifest resource names
/// that match those generated by Microsoft Visual Studio.NET, the value of
/// the attribute of the <>
/// element should match the "Default Package" of the J#.NET project, and
/// the value of the attribute
/// should be set to "".
///
///
///
/// Compile a "HelloWorld" application, including embedded resources.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("vjc")]
[ProgramLocation(LocationType.FrameworkDir)]
public class VjcTask : CompilerBase {
#region Private Instance Fields
private string _baseAddress;
private DebugOutput _debugOutput = DebugOutput.None;
private bool _secureScoping;
private string _x;
private string _libPath;
private string _jcpa;
private string _codepage;
private string _warningLevel;
#endregion Private Instance Fields
#region Private Static Fields
private static Regex _classNameRegex = new Regex(@"^((?/\*.*?(\*/|$))|[\s\.\{]+|class\s+(?\w+)|(?\w+))*");
private static Regex _namespaceRegex = new Regex(@"^((?/\*.*?(\*/|$))|[\s\.\{]+|package\s+(?(\w+(\.\w+)*)+)|(?\w+))*");
#endregion Private Static Fields
#region Public Instance Properties
///
/// The preferred base address at which to load a DLL. The default base
/// address for a DLL is set by the .NET Framework common language
/// runtime.
///
///
/// The preferred base address at which to load a DLL.
///
///
/// This address can be specified as a decimal, hexadecimal, or octal
/// number.
///
public string BaseAddress {
get { return _baseAddress; }
set { _baseAddress = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the type of debugging information generated by the
/// compiler. The default is .
///
[TaskAttribute("debug")]
public DebugOutput DebugOutput {
get { return _debugOutput; }
set { _debugOutput = value; }
}
///
/// No longer expose this to build authors. Use
/// instead.
///
public override bool Debug {
get { return DebugOutput != DebugOutput.None; }
set { DebugOutput = DebugOutput.Enable; }
}
///
/// Specifies whether package-scoped members are accessible outside of
/// the assembly. In other words, package scope is treated as assembly
/// scope when emitting metadata. The default is .
///
///
/// if the option should be passed to the compiler;
/// otherwise, .
///
///
///
/// Corresponds to the /securescoping flag.
///
///
/// See the Visual J# Reference for details.
///
///
///
/// ]]>
///
[TaskAttribute("securescoping")]
[BooleanValidator()]
public bool SecureScoping {
get { return _secureScoping; }
set { _secureScoping = value; }
}
///
/// Specifies whether to disable language extensions.
///
///
/// The value of this property must be either all, net,
/// or an empty string.
///
///
///
/// Corresponds to the /x flag.
///
///
/// See the Visual J# Reference for details.
///
///
///
/// To disable only the .NET Framework extensions:
/// ]]>
/// To disable the .NET Framework extensions and the VJ++ 6.0 extensions:
/// ]]>
///
[TaskAttribute("x")]
public string X {
get { return _x; }
set { _x = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the location of assemblies referenced by way of the /reference flag.
///
///
///
/// Corresponds to the /libpath:dir[;dir2] flag.
///
///
/// See the Visual J# Reference for details.
///
///
[TaskAttribute("libpath")]
public string LibPath {
get { return _libPath; }
set { _libPath = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Associate Java-language/COM package names.
///
///
/// The value of this propery. must be package=namespace, @filename,
/// or an empty string.
///
///
///
/// Corresponds to the /jcpa:package=namespace and /jcpa:@filename flags.
///
///
/// See the Visual J# Reference for details.
///
///
///
/// Map package 'x' to namespace 'y':
/// ]]>
///
[TaskAttribute("jcpa")]
public string Jcpa {
get { return _jcpa; }
set { _jcpa = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the code page to use for all source code files in the
/// compilation.
///
///
///
/// Corresponds with the /codepage flag.
///
///
/// See the Visual J# Reference for details.
///
///
[TaskAttribute("codepage")]
public string Codepage {
get { return _codepage; }
set { _codepage = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the warning level for the compiler to display. Valid values
/// are 0-4. The default is 4.
///
///
/// The warning level for the compiler to display.
///
///
///
/// Corresponds with the /warn option.
///
///
[TaskAttribute("warninglevel")]
[Int32Validator(0, 4)]
public string WarningLevel {
get { return _warningLevel; }
set { _warningLevel = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Controls which warnings should be reported as errors.
///
///
/// Override to avoid exposing this to build authors, as the Visual J#
/// compiler does not allow control over which warnings should be
/// reported as errors.
///
public override WarningAsError WarningAsError {
get { return base.WarningAsError; }
}
#endregion Public Instance Properties
#region Override implementation of CompilerBase
///
/// Reference packages
///
///
/// Override to avoid exposing this to build authors, as the Visual J#
/// compiler does not support package references.
///
public override PackageCollection Packages {
get { return base.Packages; }
set { base.Packages = value; }
}
///
/// Link the specified modules into this assembly.
///
///
/// Override to avoid exposing this to build authors, as the Visual J#
/// compiler does not support linking modules.
///
public override AssemblyFileSet Modules {
get { return base.Modules; }
set { base.Modules = value; }
}
///
/// Writes module references to the specified .
///
/// The to which the module references should be written.
protected override void WriteModuleReferences(TextWriter writer) {
if (Modules.FileNames.Count > 0) {
Log(Level.Warning, ResourceUtils.GetString("String_JscDoesNotSupportLinkingModules"));
}
}
///
/// Writes the compiler options to the specified .
///
/// to which the compiler options should be written.
protected override void WriteOptions(TextWriter writer) {
// the base address for the DLL
if (BaseAddress != null) {
WriteOption(writer, "baseaddress", BaseAddress);
}
// handle secure scoping.
if (SecureScoping) {
WriteOption(writer, "securescoping");
}
// handle the disable framework extensions option.
if (X != null) {
WriteOption(writer, "x", X);
}
// handle the libpath option.
if (LibPath != null ) {
WriteOption(writer, "libpath", LibPath);
}
// handle the jcpa option.
if (Jcpa != null) {
WriteOption(writer, "jcpa", Jcpa);
}
// handle the codepage option.
if (Codepage != null) {
WriteOption(writer, "codepage", Codepage);
}
// handle debug builds.
switch (DebugOutput) {
case DebugOutput.None:
break;
case DebugOutput.Enable:
WriteOption(writer, "debug");
WriteOption(writer, "define", "DEBUG");
WriteOption(writer, "define", "TRACE");
break;
case DebugOutput.Full:
WriteOption(writer, "debug");
break;
case DebugOutput.PdbOnly:
WriteOption(writer, "debug", "pdbonly");
break;
default:
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2011"), DebugOutput), Location);
}
if (WarningLevel != null) {
WriteOption(writer, "warn", WarningLevel);
}
// win32res
if (Win32Res != null) {
WriteOption (writer, "win32res", Win32Res.FullName);
}
}
///
/// Gets the file extension required by the current compiler.
///
///
/// For the J# compiler, the file extension is always jsl.
///
public override string Extension {
get { return "jsl"; }
}
///
/// Gets the class name regular expression for the language of the
/// current compiler.
///
///
/// Class name regular expression for the language of the current
/// compiler.
///
protected override Regex ClassNameRegex {
get { return _classNameRegex; }
}
///
/// Gets the namespace regular expression for the language of the
/// current compiler.
///
///
/// Namespace regular expression for the language of the current
/// compiler.
///
protected override Regex NamespaceRegex {
get { return _namespaceRegex; }
}
///
/// Override to avoid exposing the configuration setting for this
/// task as Visual J# will never support package references.
///
///
/// , as the Visual J# compiler will never
/// support package references.
///
public override bool SupportsPackageReferences {
get { return false; }
set { }
}
#endregion Override implementation of CompilerBase
}
}
nant-0.92-rc1/src/NAnt.DotNet/Tasks/CompilerBase.cs 0000644 0001750 0001750 00000210322 11757302273 021634 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Mike Krueger (mike@icsharpcode.net)
// Ian MacLean (ian_maclean@another.com)
// Giuseppe Greco (giuseppe.greco@agamura.com)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.DotNet.Types;
namespace NAnt.DotNet.Tasks {
///
/// Provides the abstract base class for compiler tasks.
///
public abstract class CompilerBase : ExternalProgramBase {
#region Private Instance Fields
private string _responseFileName;
private FileInfo _outputFile;
private string _target;
private bool _debug;
private string _define;
private FileInfo _win32icon;
private FileInfo _win32res;
private bool _warnAsError;
private WarningAsError _warningAsError = new WarningAsError();
private string _noWarn;
private CompilerWarningCollection _suppressWarnings = new CompilerWarningCollection();
private bool _forceRebuild;
private string _mainType;
private string _keyContainer;
private FileInfo _keyFile;
private DelaySign _delaySign = DelaySign.NotSet;
private AssemblyFileSet _references = new AssemblyFileSet();
private FileSet _lib = new FileSet();
private AssemblyFileSet _modules = new AssemblyFileSet();
private FileSet _sources = new FileSet();
private ResourceFileSetCollection _resourcesList = new ResourceFileSetCollection();
private PackageCollection _packages = new PackageCollection();
// framework configuration settings
private bool _supportsPackageReferences;
private bool _supportsWarnAsErrorList;
private bool _supportsNoWarnList;
private bool _supportsKeyContainer;
private bool _supportsKeyFile;
private bool _supportsDelaySign;
#endregion Private Instance Fields
#region Protected Static Fields
///
/// Contains a list of extensions for all file types that should be treated as
/// 'code-behind' when looking for resources. Ultimately this will determine
/// if we use the "namespace+filename" or "namespace+classname" algorithm, since
/// code-behind will use the "namespace+classname" algorithm.
///
protected static string[] CodebehindExtensions = {".aspx", ".asax", ".ascx", ".asmx"};
///
/// Case-insensitive list of valid culture names for this platform.
///
///
/// The key of the is the culture name and
/// the value is .
///
protected readonly static Hashtable CultureNames;
#endregion Protected Static Fields
#region Static Constructor
///
/// Class constructor for .
///
static CompilerBase() {
CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.AllCultures);
// initialize hashtable to necessary size
CultureNames = CollectionsUtil.CreateCaseInsensitiveHashtable(
allCultures.Length);
// fill the culture list
foreach (CultureInfo ci in allCultures) {
CultureNames[ci.Name] = null;
}
}
#endregion Static Constructor
#region Public Instance Properties
///
/// Generate debug output. The default is .
///
///
/// Only used for <jsc> tasks, but retained for backward
/// compatibility (Clover.NET).
///
[TaskAttribute("debug")]
[BooleanValidator()]
public virtual bool Debug {
get { return _debug; }
set { _debug = value; }
}
///
/// The output file created by the compiler.
///
[TaskAttribute("output", Required=true)]
public FileInfo OutputFile {
get { return _outputFile; }
set { _outputFile = value; }
}
///
/// Output type. Possible values are exe, winexe,
/// library or module.
///
[TaskAttribute("target", Required=true)]
[StringValidator(AllowEmpty=false)]
public string OutputTarget {
get { return _target; }
set { _target = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Define conditional compilation symbol(s).
///
///
///
/// Corresponds to /d[efine]: flag.
///
///
[TaskAttribute("define")]
public string Define {
get { return _define; }
set { _define = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Icon to associate with the application.
///
///
///
/// Corresponds to /win32icon: flag.
///
///
[TaskAttribute("win32icon")]
public FileInfo Win32Icon {
get { return _win32icon; }
set { _win32icon = value; }
}
///
/// Specifies a Win32 resource file (.res).
///
///
///
/// Corresponds to /win32res[ource]: flag.
///
///
[TaskAttribute("win32res")]
public FileInfo Win32Res {
get { return _win32res; }
set { _win32res = value; }
}
///
/// Instructs the compiler to treat all warnings as errors. The default
/// is .
///
///
///
/// Corresponds to the /warnaserror[+|-] flag of the compiler.
///
///
/// When this property is set to , any messages
/// that would ordinarily be reported as warnings will instead be
/// reported as errors.
///
///
[TaskAttribute("warnaserror")]
[BooleanValidator()]
public bool WarnAsError {
get { return _warnAsError; }
set { _warnAsError = value; }
}
///
/// Controls which warnings should be reported as errors.
///
[BuildElement("warnaserror")]
public virtual WarningAsError WarningAsError {
get { return _warningAsError; }
}
///
/// Specifies a comma-separated list of warnings that should be suppressed
/// by the compiler.
///
///
/// Comma-separated list of warnings that should be suppressed by the
/// compiler.
///
///
///
/// Corresponds with the /nowarn flag.
///
///
[TaskAttribute("nowarn")]
[Obsolete("Use the element instead.", false)]
public virtual string NoWarn {
get { return _noWarn; }
set { _noWarn = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies a list of warnings that you want the compiler to suppress.
///
[BuildElementCollection("nowarn", "warning")]
public virtual CompilerWarningCollection SuppressWarnings {
get { return _suppressWarnings; }
}
///
/// Instructs NAnt to recompile the output file regardless of the file timestamps.
///
///
/// When this parameter is to , NAnt will always
/// run the compiler to rebuild the output file, regardless of the file timestamps.
///
[TaskAttribute("rebuild")]
[BooleanValidator()]
public bool ForceRebuild {
get { return _forceRebuild; }
set { _forceRebuild = value; }
}
///
/// Specifies which type contains the Main method that you want to use
/// as the entry point into the program.
///
///
///
/// Corresponds to the /m[ain]: flag of the compiler.
///
///
/// Use this property when creating an executable file. If this property
/// is not set, the compiler searches for a valid Main method in all
/// public classes.
///
///
[TaskAttribute("main")]
public string MainType {
get { return _mainType; }
set { _mainType = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the key pair container used to strongname the assembly.
///
[TaskAttribute("keycontainer")]
public virtual string KeyContainer {
get { return _keyContainer; }
set { _keyContainer = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies a strong name key file.
///
[TaskAttribute("keyfile")]
public virtual FileInfo KeyFile {
get { return _keyFile; }
set { _keyFile = value; }
}
///
/// Specifies whether to delay sign the assembly using only the public
/// portion of the strong name key. The default is
/// .
///
[TaskAttribute("delaysign")]
public virtual DelaySign DelaySign {
get { return _delaySign; }
set { _delaySign = value; }
}
///
/// Additional directories to search in for assembly references.
///
///
///
/// Corresponds with the /lib[path]: flag.
///
///
[BuildElement("lib")]
[Obsolete("Use the element in and instead.", false)]
public FileSet Lib {
get { return _lib; }
set {_lib = value; }
}
///
/// Reference metadata from the specified assembly files.
///
[BuildElement("references")]
public AssemblyFileSet References {
get { return _references; }
set { _references = value; }
}
///
/// Specifies list of packages to reference.
///
[BuildElementCollection("pkg-references", "package")]
public virtual PackageCollection Packages {
get { return _packages; }
set { _packages = value; }
}
///
/// Resources to embed.
///
///
///
/// This can be a combination of resx files and file resources.
///
///
/// .resx files will be compiled by and then
/// embedded into the resulting executable.
///
///
/// The property is used to make
/// up the resource name added to the assembly manifest for non-resx
/// files.
///
///
/// For .resx files the namespace from the matching source file is used
/// as prefix. This matches the behaviour of Visual Studio.
///
///
/// Multiple resources tags with different namespace prefixes may be
/// specified.
///
///
[BuildElementArray("resources")]
public ResourceFileSetCollection ResourcesList {
get { return _resourcesList; }
}
///
/// Link the specified modules into this assembly.
///
[BuildElement("modules")]
public virtual AssemblyFileSet Modules {
get { return _modules; }
set { _modules = value; }
}
///
/// The set of source files for compilation.
///
[BuildElement("sources", Required=true)]
public FileSet Sources {
get { return _sources; }
set { _sources = value; }
}
///
/// Indicates whether package references are supported by compiler for
/// a given target framework. The default is .
///
[FrameworkConfigurable("supportspackagereferences")]
public virtual bool SupportsPackageReferences {
get { return _supportsPackageReferences; }
set { _supportsPackageReferences = value; }
}
///
/// Indicates whether the compiler for a given target framework supports
/// the "warnaserror" option that takes a list of warnings. The default
/// is .
///
[FrameworkConfigurable("supportswarnaserrorlist")]
public virtual bool SupportsWarnAsErrorList {
get { return _supportsWarnAsErrorList; }
set { _supportsWarnAsErrorList = value; }
}
///
/// Indicates whether the compiler for a given target framework supports
/// a command line option that allows a list of warnings to be
/// suppressed. The default is .
///
[FrameworkConfigurable("supportsnowarnlist")]
public virtual bool SupportsNoWarnList {
get { return _supportsNoWarnList; }
set { _supportsNoWarnList = value; }
}
///
/// Indicates whether the compiler for a given target framework supports
/// the "keycontainer" option. The default is .
///
[FrameworkConfigurable("supportskeycontainer")]
public virtual bool SupportsKeyContainer {
get { return _supportsKeyContainer; }
set { _supportsKeyContainer = value; }
}
///
/// Indicates whether the compiler for a given target framework supports
/// the "keyfile" option. The default is .
///
[FrameworkConfigurable("supportskeyfile")]
public virtual bool SupportsKeyFile {
get { return _supportsKeyFile; }
set { _supportsKeyFile = value; }
}
///
/// Indicates whether the compiler for a given target framework supports
/// the "delaysign" option. The default is .
///
[FrameworkConfigurable("supportsdelaysign")]
public virtual bool SupportsDelaySign {
get { return _supportsDelaySign; }
set { _supportsDelaySign = value; }
}
#endregion Public Instance Properties
#region Protected Instance Properties
///
/// Gets the file extension required by the current compiler.
///
///
/// The file extension required by the current compiler.
///
public abstract string Extension {
get;
}
///
/// Gets the class name regular expression for the language of the current compiler.
///
/// class name regular expression for the language of the current compiler
protected abstract Regex ClassNameRegex {
get;
}
///
/// Gets the namespace regular expression for the language of the current compiler.
///
/// namespace regular expression for the language of the current compiler
protected abstract Regex NamespaceRegex {
get;
}
#endregion Protected Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Gets the command-line arguments for the external program.
///
///
/// The command-line arguments for the external program.
///
public override string ProgramArguments {
get { return "@" + "\"" + _responseFileName + "\""; }
}
///
/// Compiles the sources and resources.
///
protected override void ExecuteTask() {
if (NeedsCompiling()) {
// create temp response file to hold compiler options
_responseFileName = Path.GetTempFileName();
StreamWriter writer = new StreamWriter(_responseFileName);
// culture names are not case-sensitive
Hashtable cultureResources = CollectionsUtil.CreateCaseInsensitiveHashtable();
// will hold temporary compiled resources
StringCollection compiledResourceFiles = new StringCollection();
try {
// ensure base directory is set, even if fileset was not initialized
// from XML
if (References.BaseDirectory == null) {
References.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (Lib.BaseDirectory == null) {
Lib.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (Modules.BaseDirectory == null) {
Modules.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (Sources.BaseDirectory == null) {
Sources.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
// copy lib path details across to the children Assembly filesets
foreach(string directoryName in Lib.DirectoryNames){
References.Lib.DirectoryNames.Add(directoryName);
Modules.Lib.DirectoryNames.Add(directoryName);
}
// rescan to ensure correct assembly resolution
References.Scan();
Modules.Scan();
// create the base directory if it does not exist
if (!Directory.Exists(OutputFile.DirectoryName)) {
Directory.CreateDirectory(OutputFile.DirectoryName);
}
Log(Level.Info, ResourceUtils.GetString("String_CompilingFiles"),
Sources.FileNames.Count, OutputFile.FullName);
// specific compiler options
WriteOptions(writer);
// suppresses display of the sign-on banner
WriteOption(writer, "nologo");
// specify output file format
WriteOption(writer, "target", OutputTarget);
WriteConditionalCompilationConstants(writer);
// the name of the output file
WriteOption(writer, "out", OutputFile.FullName);
if (Win32Icon != null) {
WriteOption(writer, "win32icon", Win32Icon.FullName);
}
// writes the option that specifies the class containing
// the Main method that should be called when the program
// starts.
if (MainType != null) {
WriteOption(writer, "main", MainType);
}
if (KeyContainer != null) {
if (SupportsKeyContainer) {
WriteOption(writer, "keycontainer", KeyContainer);
} else {
Log(Level.Warning, ResourceUtils.GetString("String_CompilerDoesNotSupportKeyContainer"),
Project.TargetFramework.Description);
}
}
if (KeyFile != null) {
if (SupportsKeyFile) {
WriteOption(writer, "keyfile", KeyFile.FullName);
} else {
Log(Level.Warning, ResourceUtils.GetString("String_CompilerDoesNotSupportKeyFile"),
Project.TargetFramework.Description);
}
}
if (DelaySign != DelaySign.NotSet) {
if (SupportsDelaySign) {
switch (DelaySign) {
case DelaySign.Yes:
WriteOption(writer, "delaysign+");
break;
case DelaySign.No:
WriteOption(writer, "delaysign-");
break;
default:
throw new NotSupportedException (string.Format (
CultureInfo.InvariantCulture, "The {0}" +
"value for \"delaysign\" is not supported.",
DelaySign));
}
} else {
Log(Level.Warning, ResourceUtils.GetString("String_CompilerDoesNotSupportDelaySign"),
Project.TargetFramework.Description);
}
}
// writes package references to the response file
WritePackageReferences(writer);
// write warnings to (not) treat as errors to the response file
WriteWarningsAsError(writer);
// write list of warnings to suppress
WriteNoWarnList(writer);
// writes assembly references to the response file
foreach (string fileName in References.FileNames) {
WriteOption(writer, "reference", fileName);
}
// writes module references to the response file
WriteModuleReferences(writer);
// compile resources
foreach (ResourceFileSet resources in ResourcesList) {
// resx files
if (resources.ResxFiles.FileNames.Count > 0) {
// compile the resx files to .resources files in the
// same dir as the input files
CompileResxResources(resources.ResxFiles.FileNames);
// Resx args
foreach (string fileName in resources.ResxFiles.FileNames) {
// determine manifest resource name
string manifestResourceName = this.GetManifestResourceName(
resources, fileName);
// determine the filenames of the .resources file
// generated by the task
string tmpResourcePath = Path.ChangeExtension(fileName, ".resources");
compiledResourceFiles.Add(tmpResourcePath);
// check if resource is localized
CultureInfo resourceCulture = CompilerBase.GetResourceCulture(fileName,
Path.ChangeExtension(fileName, Extension));
if (resourceCulture != null) {
if (!cultureResources.ContainsKey(resourceCulture.Name)) {
// initialize collection for holding
// resource file for this culture
cultureResources.Add(resourceCulture.Name, new Hashtable());
}
// store resulting .resources file for later linking
((Hashtable) cultureResources[resourceCulture.Name])[manifestResourceName] = tmpResourcePath;
} else {
// regular embedded resources (using filename and manifest resource name).
string resourceoption = string.Format(CultureInfo.InvariantCulture, "{0},{1}", tmpResourcePath, manifestResourceName);
// write resource option to response file
WriteOption(writer, "resource", resourceoption);
}
}
}
// other resources
foreach (string fileName in resources.NonResxFiles.FileNames) {
// determine manifest resource name
string manifestResourceName = this.GetManifestResourceName(
resources, fileName);
// check if resource is localized
CultureInfo resourceCulture = CompilerBase.GetResourceCulture(fileName,
Path.ChangeExtension(fileName, Extension));
if (resourceCulture != null) {
if (!cultureResources.ContainsKey(resourceCulture.Name)) {
// initialize collection for holding
// resource file for this culture
cultureResources.Add(resourceCulture.Name, new Hashtable());
}
// store resource filename for later linking
((Hashtable) cultureResources[resourceCulture.Name])[manifestResourceName] = fileName;
} else {
string resourceoption = string.Format(CultureInfo.InvariantCulture,
"{0},{1}",fileName, manifestResourceName);
WriteOption(writer, "resource", resourceoption);
}
}
}
// write sources to compile to response file
foreach (string fileName in Sources.FileNames) {
writer.WriteLine("\"" + fileName + "\"");
}
// make sure to close the response file otherwise contents
// will not be written to disk and ExecuteTask() will fail.
writer.Close();
if (Verbose) {
// display response file contents
Log(Level.Info, ResourceUtils.GetString("String_ContentsOf"), _responseFileName);
StreamReader reader = File.OpenText(_responseFileName);
Log(Level.Info, reader.ReadToEnd());
reader.Close();
}
// call base class to do the work
base.ExecuteTask();
// create a satellite assembly for each culture name
foreach (string culture in cultureResources.Keys) {
// determine directory for satellite assembly
string culturedir = Path.Combine(OutputFile.DirectoryName, culture);
// ensure diretory for satellite assembly exists
Directory.CreateDirectory(culturedir);
// determine filename of satellite assembly
FileInfo outputFile = new FileInfo(Path.Combine(culturedir,
Path.GetFileNameWithoutExtension(OutputFile.Name)
+ ".resources.dll"));
// generate satellite assembly
LinkResourceAssembly((Hashtable)cultureResources[culture],
outputFile, culture);
}
} finally {
// cleanup .resource files
foreach (string compiledResourceFile in compiledResourceFiles) {
File.Delete(compiledResourceFile);
}
// make sure we delete response file even if an exception is thrown
writer.Close(); // make sure stream is closed or file cannot be deleted
File.Delete(_responseFileName);
_responseFileName = null;
}
}
}
#endregion Override implementation of ExternalProgramBase
#region Public Instance Methods
///
/// Determines the manifest resource name of the given resource file.
///
/// The containing information that will used to assemble the manifest resource name.
/// The resource file of which the manifest resource name should be determined.
/// The logical location of the resource file.
/// The source file on which the resource file depends.
///
/// The manifest resource name of the specified resource file.
///
public string GetManifestResourceName(ResourceFileSet resources, string resourcePhysicalFile, string resourceLogicalFile, string dependentFile) {
if (resources == null) {
throw new ArgumentNullException("resources");
}
if (resourcePhysicalFile == null) {
throw new ArgumentNullException("resourcePhysicalFile");
}
if (resourceLogicalFile == null) {
throw new ArgumentNullException("resourceLogicalFile");
}
// make sure the resource file exists
if (!File.Exists(resourcePhysicalFile)) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2009"), resourcePhysicalFile),
Location);
}
// will hold the manifest resource name
string manifestResourceName = null;
// check if we're dealing with a localized resource
CultureInfo resourceCulture = CompilerBase.GetResourceCulture(
resourceLogicalFile, dependentFile);
// determine the resource type
switch (Path.GetExtension(resourcePhysicalFile).ToLower(CultureInfo.InvariantCulture)) {
case ".resx":
// try and get manifest resource name from dependent file
ResourceLinkage resourceLinkage = GetResourceLinkage(
dependentFile, resourceCulture);
if (resourceLinkage == null || !resourceLinkage.IsValid) {
// no resource linkage could be determined (no dependent
// file or dependent file does not exist) or dependent
// file is no (valid) source file
manifestResourceName = Path.ChangeExtension(
resources.GetManifestResourceName(resourcePhysicalFile,
resourceLogicalFile), "resources");
} else {
if (!resourceLinkage.HasClassName) {
// use filename of resource file to determine class name
string className = Path.GetFileNameWithoutExtension(
resourcePhysicalFile);
// cater for asax/aspx special cases. eg. a resource file
// named "WebForm1.aspx(.resx)" will here be transformed to
// "WebForm1"
// we assume that the class name of a codebehind file
// is equal to the file name of that codebehind file
// (without extension)
if (Path.GetExtension(className) != string.Empty) {
string codebehindExtension = Path.GetExtension(
className).ToLower(CultureInfo.InvariantCulture);
foreach (string extension in CodebehindExtensions) {
if (extension == codebehindExtension) {
className = Path.GetFileNameWithoutExtension(
className);
break;
}
}
}
resourceLinkage.ClassName = className;
}
// ensure we have information necessary to determine the
// manifest resource name
if (resourceLinkage.IsValid) {
manifestResourceName = resourceLinkage.ToString()
+ ".resources";
} else {
// we should actually never get here, but just in case ...
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2010"), resourcePhysicalFile), Location);
}
}
break;
case ".resources":
// determine resource name, and leave culture information
// in manifest resource name
manifestResourceName = resources.GetManifestResourceName(
resourcePhysicalFile, resourceLogicalFile);
break;
default:
// VS.NET handles an embedded resource file named licenses.licx
// in the root of the project and without culture in a special
// way
if (Path.GetFileName(resourcePhysicalFile) == "licenses.licx") {
// the manifest resource name will be
/// ]]>
///
///
[TaskName("resgen")]
[ProgramLocation(LocationType.FrameworkSdkDir)]
public class ResGenTask : ExternalProgramBase {
#region Private Instance Fields
private StringBuilder _arguments = new StringBuilder();
private AssemblyFileSet _assemblies = new AssemblyFileSet();
private FileInfo _inputFile;
private FileInfo _outputFile;
private string _programFileName;
private ResourceFileSet _resources = new ResourceFileSet();
private string _targetExt = "resources";
private DirectoryInfo _toDir;
private DirectoryInfo _workingDirectory;
private bool _useSourcePath;
private ArrayList _qualifiedResources = new ArrayList();
// framework configuration settings
private bool _supportsAssemblyReferences;
private bool _supportsExternalFileReferences;
#endregion Private Instance Fields
#region Private Static Fields
private const int _maxCmdLineLength = 30000;
#endregion Private Static Fields
#region Public Instance Properties
///
/// Input file to process.
///
///
/// The full path to the input file.
///
[TaskAttribute("input", Required=false)]
public FileInfo InputFile {
get { return _inputFile; }
set { _inputFile = value; }
}
///
/// The resource file to output.
///
[TaskAttribute("output", Required=false)]
public FileInfo OutputFile {
get { return _outputFile; }
set { _outputFile = value; }
}
///
/// The target type. The default is resources.
///
[TaskAttribute("target", Required=false)]
public string TargetExt {
get { return _targetExt; }
set { _targetExt = StringUtils.ConvertEmptyToNull(value); }
}
///
/// The directory to which outputs will be stored.
///
[TaskAttribute("todir", Required=false)]
public DirectoryInfo ToDirectory {
get { return _toDir; }
set { _toDir = value; }
}
///
/// Use each source file's directory as the current directory for
/// resolving relative file paths. The default is .
/// Only supported when targeting .NET 2.0 (or higher).
///
[TaskAttribute("usesourcepath", Required=false)]
public bool UseSourcePath {
get { return _useSourcePath; }
set { _useSourcePath = value; }
}
///
/// Takes a list of .resx or .txt files to convert to .resources files.
///
[BuildElement("resources")]
public ResourceFileSet Resources {
get { return _resources; }
set { _resources = value; }
}
///
/// Reference metadata from the specified assembly files.
///
[BuildElement("assemblies")]
public AssemblyFileSet Assemblies {
get { return _assemblies; }
set { _assemblies = value; }
}
///
/// Indicates whether assembly references are supported by the
/// resgen tool for the current target framework. The default
/// is .
///
[FrameworkConfigurable("supportsassemblyreferences")]
public bool SupportsAssemblyReferences {
get { return _supportsAssemblyReferences; }
set { _supportsAssemblyReferences = value; }
}
///
/// Indicates whether external file references are supported by the
/// resgen tool for the current target framework. The default
/// is .
///
[FrameworkConfigurable("supportsexternalfilereferences")]
public bool SupportsExternalFileReferences {
get { return _supportsExternalFileReferences; }
set { _supportsExternalFileReferences = value; }
}
///
/// For internal use only !
///
public ArrayList QualifiedResources {
get { return _qualifiedResources; }
}
#endregion Public Instance Properties
#region Private Instance Properties
private bool RequiresAssemblyReferences {
get {
if (Resources.FileNames.Count > 0 || QualifiedResources.Count > 0) {
foreach (string resourceFile in Resources.FileNames) {
if (ReferencesThirdPartyAssemblies(resourceFile)) {
return true;
}
}
foreach (QualifiedResource resource in QualifiedResources) {
if (ReferencesThirdPartyAssemblies(resource.Input.FullName)) {
return true;
}
}
} else if (InputFile != null) {
return ReferencesThirdPartyAssemblies(InputFile.FullName);
}
return false;
}
}
#endregion Private Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Gets the working directory for the application.
///
///
/// The working directory for the application.
///
public override DirectoryInfo BaseDirectory {
get {
if (_workingDirectory == null) {
return base.BaseDirectory;
}
return _workingDirectory;
}
set {
_workingDirectory = value;
}
}
///
/// Gets the command line arguments for the external program.
///
///
/// The command line arguments for the external program.
///
public override string ProgramArguments {
get { return _arguments.ToString(); }
}
///
/// Gets the filename of the external program to start.
///
///
/// The filename of the external program.
///
///
/// Override in derived classes to explicitly set the location of the
/// external tool.
///
public override string ProgramFileName {
get {
if (_programFileName == null) {
_programFileName = base.ProgramFileName;
}
return _programFileName;
}
}
///
/// Updates the of the specified
/// .
///
/// The of which the should be updated.
protected override void PrepareProcess(Process process) {
if (!SupportsAssemblyReferences) {
// avoid copying the assembly references (and resgen) to a
// temporary directory if not necessary
if (Assemblies.FileNames.Count == 0 || !RequiresAssemblyReferences) {
// further delegate preparation to base class
base.PrepareProcess(process);
// no further processing required
return;
}
// use a newly created temporary directory as working directory
BaseDirectory = FileUtils.GetTempDirectory();
// create instance of Copy task
CopyTask ct = new CopyTask();
// inherit project from current task
ct.Project = Project;
// inherit namespace manager from current task
ct.NamespaceManager = NamespaceManager;
// parent is current task
ct.Parent = this;
// inherit verbose setting from resgen task
ct.Verbose = Verbose;
// only output warning messages or higher, unless we're running
// in verbose mode
if (!ct.Verbose) {
ct.Threshold = Level.Warning;
}
// make sure framework specific information is set
ct.InitializeTaskConfiguration();
// set parent of child elements
ct.CopyFileSet.Parent = ct;
// inherit project from solution task for child elements
ct.CopyFileSet.Project = ct.Project;
// inherit namespace manager from solution task
ct.CopyFileSet.NamespaceManager = ct.NamespaceManager;
// set base directory of fileset
ct.CopyFileSet.BaseDirectory = Assemblies.BaseDirectory;
// copy all files to base directory itself
ct.Flatten = true;
// copy referenced assemblies
foreach (string file in Assemblies.FileNames) {
ct.CopyFileSet.Includes.Add(file);
}
// copy command line tool (and related files) to working directory, eg.:
// /resgen.exe
// /resgen.exe.manifest
ct.CopyFileSet.Includes.Add(base.ProgramFileName + "*");
// set destination directory
ct.ToDirectory = BaseDirectory;
// increment indentation level
ct.Project.Indent();
try {
// execute task
ct.Execute();
} finally {
// restore indentation level
ct.Project.Unindent();
}
// change program to execute the tool in working directory as
// that will allow this tool to resolve assembly references
// using assemblies stored in the same directory
_programFileName = Path.Combine(BaseDirectory.FullName,
Path.GetFileName(base.ProgramFileName));
}
// further delegate preparation to base class
base.PrepareProcess(process);
}
///
/// Converts a single file or group of files.
///
protected override void ExecuteTask() {
// ensure base directory is set, even if fileset was not initialized
// from XML
if (Assemblies.BaseDirectory == null) {
Assemblies.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (Resources.BaseDirectory == null) {
Resources.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
// clear buffer
_arguments.Length = 0;
if (Resources.FileNames.Count > 0 || QualifiedResources.Count > 0) {
if (OutputFile != null) {
throw new BuildException(ResourceUtils.GetString("NA2026"), Location);
}
foreach (string fileName in Resources.FileNames) {
FileInfo inputFile = new FileInfo(fileName);
FileInfo outputFile = GetOutputFile(new FileInfo(Path.Combine(
inputFile.DirectoryName, Resources.GetManifestResourceName(fileName))));
WriteCommandLineOptions(inputFile, outputFile);
}
// used by task
foreach (QualifiedResource resource in QualifiedResources) {
WriteCommandLineOptions(resource.Input, resource.Output);
}
} else {
// Single file situation
if (InputFile == null) {
throw new BuildException(ResourceUtils.GetString("NA2027"), Location);
}
FileInfo outputFile = GetOutputFile(InputFile);
if (NeedsCompiling(InputFile, outputFile)) {
// ensure output directory exists
if (!outputFile.Directory.Exists) {
outputFile.Directory.Create();
}
if (UseSourcePath) {
if (SupportsExternalFileReferences) {
_arguments.Append("/useSourcePath");
} else {
Log(Level.Warning, ResourceUtils.GetString(
"String_ResourceCompilerDoesNotSupportExternalReferences"),
Project.TargetFramework.Description);
}
}
_arguments.Append(string.Format(CultureInfo.InvariantCulture,
" \"{0}\" \"{1}\"", InputFile.FullName, outputFile.FullName));
}
}
if (_arguments.Length != 0) {
try {
// call base class to do the work
base.ExecuteTask();
} finally {
// we only need to remove temporary directory if it was
// actually created
if (_workingDirectory != null) {
// delete temporary directory and all files in it
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = Project;
deleteTask.Parent = this;
deleteTask.InitializeTaskConfiguration();
deleteTask.Directory = _workingDirectory;
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
}
}
}
#endregion Override implementation of ExternalProgramBase
#region Public Instance Methods
///
/// Cleans up generated files.
///
public void RemoveOutputs() {
foreach (string filename in Resources.FileNames) {
FileInfo outputFile = GetOutputFile(new FileInfo(Path.Combine(
Path.GetDirectoryName(filename), Resources.GetManifestResourceName(filename))));
if (filename != outputFile.FullName) {
outputFile.Delete();
}
}
foreach (QualifiedResource resource in QualifiedResources) {
resource.Output.Delete();
}
if (InputFile != null) {
FileInfo outputFile = GetOutputFile(InputFile);
if (InputFile.FullName != outputFile.FullName) {
outputFile.Delete();
}
}
}
#endregion Public Instance Methods
#region Protected Instance Methods
///
/// Determines whether the specified input file needs to be compiled.
///
/// The input file.
/// The output file.
///
/// if the input file need to be compiled;
/// otherwise .
///
protected virtual bool NeedsCompiling(FileInfo inputFile, FileInfo outputFile) {
if (!outputFile.Exists) {
Log(Level.Verbose, ResourceUtils.GetString("String_OutputFileDoesNotExist"),
outputFile.FullName);
return true;
}
// check if input file was updated
string fileName = FileSet.FindMoreRecentLastWriteTime(inputFile.FullName, outputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
// check if reference assemblies were updated
fileName = FileSet.FindMoreRecentLastWriteTime(Assemblies.FileNames, outputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
// check if we're dealing with a resx file
if (string.Compare(inputFile.Extension, ".resx", true, CultureInfo.InvariantCulture) == 0) {
StringCollection externalFileReferences = GetExternalFileReferences(inputFile);
if (externalFileReferences != null) {
fileName = FileSet.FindMoreRecentLastWriteTime(externalFileReferences, outputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
}
}
// if we made it here then we don't have to recompile
return false;
}
#endregion Protected Instance Methods
#region Private Instance Methods
///
/// Determines the full path and extension for the output file.
///
/// The output file for which the full path and extension should be determined.
///
/// The full path (with extensions) for the specified file.
///
private FileInfo GetOutputFile(FileInfo file) {
FileInfo outputFile;
// if output is empty just change the extension
if (OutputFile == null) {
if (ToDirectory == null) {
outputFile = file;
} else {
outputFile = new FileInfo(Path.Combine(ToDirectory.FullName, file.Name));
}
outputFile = new FileInfo(Path.ChangeExtension(outputFile.FullName, TargetExt));
} else {
outputFile = OutputFile;
}
return outputFile;
}
///
/// Determines whether the specified resource file references third
/// party assemblies by checking whether a <data> element exists
/// with a "type" attribute that does not start with
/// "System.".
///
/// The resource file to check.
///
/// if the resource file references third party
/// assemblies, or an error occurred; otherwise, .
///
///
/// This check will only be accurate for 1.0 resource file, but the
/// 2.0 resx files can only be compiled with a resgen tool that supports
/// assembly references, so this method will not be used anyway.
///
private bool ReferencesThirdPartyAssemblies(string resourceFile) {
try {
if (!File.Exists(resourceFile)) {
return false;
}
// only resx files require assembly references
if (string.Compare(Path.GetExtension(resourceFile), ".resx", true, CultureInfo.InvariantCulture) != 0) {
return false;
}
using (StreamReader sr = new StreamReader(resourceFile, true)) {
XPathDocument xpathDoc = new XPathDocument(new XmlTextReader(sr));
// determine the number of elements that either have
// a "mimetype" attribute (meaning it contains a serialized
// instance that might be of a referenced assembly) or a
// "type" attribute with a value that does not start with
// "System." and is not fully qualified
int count = xpathDoc.CreateNavigator().Select("/root/data[@mimetype or (@type and not(starts-with(@type, 'System.') and contains(@type,'PublicKeyToken=')))]").Count;
// if there are no elements of a third party type, we
// assume that the resource file does not reference types from
// third party assemblies
return count > 0;
}
} catch (Exception) {
// have the resgen tool deal with issues (eg. invalid xml)
return true;
}
}
///
/// Returns a list of external file references for the specified file.
///
/// The resx file for which a list of external file references should be returned.
///
/// A list of external file references for the specified file, or
/// if does not
/// exist or does not support external file references.
///
private StringCollection GetExternalFileReferences(FileInfo resxFile) {
if (!resxFile.Exists) {
return null;
}
using (StreamReader sr = new StreamReader(resxFile.FullName, true)) {
XPathDocument xpathDoc = new XPathDocument(new XmlTextReader(sr));
XPathNavigator xpathNavigator = xpathDoc.CreateNavigator();
// check resheader version
xpathNavigator.Select("/root/resheader[@name = 'version']/value");
XPathNodeIterator nodeIterator = xpathNavigator.Select("/root/resheader[@name = 'version']/value");
if (nodeIterator.MoveNext()) {
string version = nodeIterator.Current.Value;
// 1.0 resx files do not support external file references
if (version == "1.0.0.0") {
return null;
}
}
StringCollection externalFiles = new StringCollection();
string baseExternalFileDirectory = UseSourcePath ? resxFile.DirectoryName
: Project.BaseDirectory;
// determine the number of elements that have a "type"
// attribute with a value that does not start with "System."
XPathNodeIterator xfileIterator = xpathNavigator.Select("/root/data[@type = 'System.Resources.ResXFileRef, System.Windows.Forms']/value");
while (xfileIterator.MoveNext()) {
string[] parts = xfileIterator.Current.Value.Split(';');
if (parts.Length <= 1) {
continue;
}
externalFiles.Add(Path.Combine(baseExternalFileDirectory, parts[0]));
}
return externalFiles;
}
}
private void WriteCommandLineOptions(FileInfo inputFile, FileInfo outputFile) {
if (!NeedsCompiling(inputFile, outputFile)) {
return;
}
// ensure output directory exists
if (!outputFile.Directory.Exists) {
outputFile.Directory.Create();
}
string cmdLineArg = string.Format(CultureInfo.InvariantCulture,
"\"{0},{1}\" ", inputFile, outputFile.FullName);
// check if adding arguments to compile current resx to
// total command line would cause it to exceed maximum
// length
bool maxCmdLineExceeded = (_arguments.Length + cmdLineArg.Length > _maxCmdLineLength);
// if this is the first resx that we're compiling, or the
// first one of the next execution of the resgen tool, then
// add options to command line
if (_arguments.Length == 0 || maxCmdLineExceeded) {
StringBuilder sb = new StringBuilder ();
// bug #1415272: first write assembly references, to make sure these
// are taken into account when calculating the length of the command
// line
if (SupportsAssemblyReferences) {
foreach (string assembly in Assemblies.FileNames) {
sb.AppendFormat (CultureInfo.InvariantCulture,
"/r:\"{0}\" ", assembly);
}
}
if (UseSourcePath) {
if (SupportsExternalFileReferences) {
sb.Append ("/useSourcePath ");
} else {
Log(Level.Warning, ResourceUtils.GetString(
"String_ResourceCompilerDoesNotSupportExternalReferences"),
Project.TargetFramework.Description);
}
}
sb.Append ("/compile ");
sb.Append (cmdLineArg);
cmdLineArg = sb.ToString ();
}
// if maximum length would have been exceeded by compiling
// the current resx file, then first execute the resgen
// tool
if (maxCmdLineExceeded) {
try {
// call base class to do the work
base.ExecuteTask();
} catch {
// we only need to remove temporary directory when
// an error occurred and if it was actually created
if (_workingDirectory != null) {
// delete temporary directory and all files in it
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = Project;
deleteTask.Parent = this;
deleteTask.InitializeTaskConfiguration();
deleteTask.Directory = _workingDirectory;
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
// rethrow exception
throw;
}
// reset command line arguments as we've processed them
_arguments.Length = 0;
}
// append command line arguments to compile current resx
// file to the total command line
_arguments.Append(cmdLineArg);
}
#endregion Private Instance Methods
}
///
/// For internal use only !
///
public class QualifiedResource {
#region Private Instance Fields
private FileInfo _inputFile;
private FileInfo _outputFile;
#endregion Private Instance Fields
#region Public Instance Constructors
///
/// Initializes a new instance of the
/// class for a given input and output file.
///
/// The resource to compile.
/// The compiled resource.
public QualifiedResource(FileInfo input, FileInfo output) {
_inputFile = input;
_outputFile = output;
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets the resource file to compile.
///
///
/// The resource file to compile.
///
public FileInfo Input {
get { return _inputFile; }
}
///
/// Gets the compiled resource file.
///
///
/// The compiled resource file.
///
public FileInfo Output {
get { return _outputFile; }
}
#endregion Public Instance Properties
}
}
nant-0.92-rc1/src/NAnt.DotNet/Tasks/AssemblyLinkerTask.cs 0000644 0001750 0001750 00000075240 11757302273 023046 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Joe Jones (joejo@microsoft.com)
// Gerry Shaw (gerry_shaw@yahoo.com)
// Gert Driesen (drieseng@users.sourceforge.net)
// Giuseppe Greco (giuseppe.greco@agamura.com)
using System;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Text;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.DotNet.Types;
namespace NAnt.DotNet.Tasks {
///
/// Wraps al.exe, the assembly linker for the .NET Framework.
///
///
///
/// All specified sources will be embedded using the /embed flag.
/// Other source types are not supported.
///
///
///
///
/// Create a library containing all icon files in the current directory.
///
///
///
///
///
///
///
/// ]]>
///
///
///
///
/// Create an executable assembly manifest from modules.
///
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("al")]
[ProgramLocation(LocationType.FrameworkDir)]
public class AssemblyLinkerTask : NAnt.Core.Tasks.ExternalProgramBase {
#region Private Instance Fields
private string _responseFileName;
private FileInfo _outputFile;
private string _target;
private string _algorithmID;
private string _company;
private string _configuration;
private string _copyright;
private string _culture;
private DelaySign _delaySign;
private string _description;
private FileInfo _evidenceFile;
private string _fileVersion;
private string _flags;
private string _keyContainer;
private FileInfo _keyfile;
private string _mainMethod;
private ModuleSet _modules = new ModuleSet();
private string _product;
private string _productVersion;
private FileSet _resources = new FileSet();
private EmbeddedResourceCollection _embeddedResources = new EmbeddedResourceCollection();
private FileInfo _templateFile;
private string _title;
private string _trademark;
private string _version;
private FileInfo _win32Icon;
private FileInfo _win32Res;
// framework configuration settings
private bool _supportsTemplate = true;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Specifies an algorithm (in hexadecimal) to hash all files in a
/// multifile assembly except the file that contains the assembly
/// manifest. The default algorithm is CALG_SHA1.
///
[TaskAttribute("algid", Required=false)]
[Int32Validator(Base=16)]
public string AlgorithmID {
get { return _algorithmID; }
set { _algorithmID = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies a string for the Company field in the assembly.
///
///
/// A string for the Company field in the assembly.
///
///
/// If is an empty string (""), the Win32
/// Company resource appears as a single space.
///
[TaskAttribute("company", Required=false)]
public string Company {
get { return _company; }
set { _company = value; }
}
///
/// Specifies a string for the Configuration field in the assembly.
///
///
/// A string for the Configuration field in the assembly.
///
///
/// If is an empty string (""), the Win32
/// Configuration resource appears as a single space.
///
[TaskAttribute("configuration", Required=false)]
public string Configuration {
get { return _configuration; }
set { _configuration = value; }
}
///
/// Specifies a string for the Copyright field in the assembly.
///
///
/// A string for the Copyright field in the assembly.
///
///
/// If is an empty string (""), the Win32
/// Copyright resource appears as a single space.
///
[TaskAttribute("copyright", Required=false)]
public string Copyright {
get { return _copyright; }
set { _copyright = value; }
}
///
/// The culture string associated with the output assembly.
/// The string must be in RFC 1766 format, such as "en-US".
///
///
///
/// Corresponds with the /c[ulture]: flag.
///
///
[TaskAttribute("culture", Required=false)]
public string Culture {
get { return _culture; }
set { _culture = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies whether the assembly should be partially signed. The default
/// is .
///
[TaskAttribute("delaysign", Required=false)]
public DelaySign DelaySign {
get { return _delaySign; }
set { _delaySign = value; }
}
///
/// Specifies a string for the Description field in the assembly.
///
///
/// A string for the Description field in the assembly.
///
///
/// If is an empty string (""), the Win32
/// Description resource appears as a single space.
///
[TaskAttribute("description", Required=false)]
public string Description {
get { return _description; }
set { _description = value; }
}
///
/// Security evidence file to embed.
///
///
/// The security evidence file to embed.
///
///
///
/// Corresponds with the /e[vidence] flag.
///
///
[TaskAttribute("evidence", Required=false)]
public FileInfo EvidenceFile {
get { return _evidenceFile; }
set { _evidenceFile = value; }
}
///
/// Specifies a string for the File Version field in the assembly.
///
///
/// A string for the File Version field in the assembly.
///
[TaskAttribute("fileversion", Required=false)]
public string FileVersion {
get { return _fileVersion; }
set { _fileVersion = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies a value (in hexadecimal) for the Flags field in
/// the assembly.
///
///
/// A value (in hexadecimal) for the Flags field in the assembly.
///
[TaskAttribute("flags", Required=false)]
[Int32Validator(Base=16)]
public string Flags {
get { return _flags; }
set { _flags = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies a container that holds a key pair.
///
[TaskAttribute("keycontainer")]
public string KeyContainer {
get { return _keyContainer; }
set { _keyContainer = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies a file (filename) that contains a key pair or
/// just a public key to sign an assembly.
///
///
/// The complete path to the key file.
///
///
///
/// Corresponds with the /keyf[ile]: flag.
///
///
[TaskAttribute("keyfile", Required=false)]
public FileInfo KeyFile {
get { return _keyfile; }
set { _keyfile = value; }
}
///
/// Specifies the fully-qualified name (class.method) of the method to
/// use as an entry point when converting a module to an executable file.
///
///
/// The fully-qualified name (class.method) of the method to use as an
/// entry point when converting a module to an executable file.
///
[TaskAttribute("main")]
public string MainMethod {
get { return _mainMethod; }
set { _mainMethod = StringUtils.ConvertEmptyToNull(value); }
}
///
/// One or more modules to be compiled into an assembly.
///
[BuildElement("modules")]
public ModuleSet ModuleSet {
get { return _modules; }
set { _modules = value; }
}
///
/// The name of the output file for the assembly manifest.
///
///
/// The complete output path for the assembly manifest.
///
///
///
/// Corresponds with the /out flag.
///
///
[TaskAttribute("output", Required=true)]
public FileInfo OutputFile {
get { return _outputFile; }
set { _outputFile = value; }
}
///
/// The target type (one of lib, exe, or winexe).
///
///
///
/// Corresponds with the /t[arget]: flag.
///
///
[TaskAttribute("target", Required=true)]
[StringValidator(AllowEmpty=false)]
public string OutputTarget {
get { return _target; }
set { _target = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies a string for the Product field in the assembly.
///
///
/// A string for the Product field in the assembly.
///
[TaskAttribute("product", Required=false)]
public string Product {
get { return _product; }
set { _product = value; }
}
///
/// Specifies a string for the Product Version field in the assembly.
///
///
/// A string for the Product Version field in the assembly.
///
[TaskAttribute("productversion", Required=false)]
public string ProductVersion {
get { return _productVersion; }
set { _productVersion = StringUtils.ConvertEmptyToNull(value); }
}
///
/// The set of resources to embed.
///
[BuildElement("sources")]
public FileSet Resources {
get { return _resources; }
set { _resources = value; }
}
///
/// The set of compiled resources to embed.
///
///
/// Do not yet expose this to build authors.
///
public EmbeddedResourceCollection EmbeddedResources {
get { return _embeddedResources; }
set { _embeddedResources = value; }
}
///
/// Indicates whether the assembly linker for a given target framework
/// supports the "template" option, which takes an assembly from which
/// to get all options except the culture field.
/// The default is .
///
///
/// TODO: remove this once Mono bug #74814 is fixed.
///
[FrameworkConfigurable("supportstemplate")]
public bool SupportsTemplate {
get { return _supportsTemplate; }
set { _supportsTemplate = value; }
}
///
/// Specifies an assembly from which to get all options except the
/// culture field.
///
///
/// The complete path to the assembly template.
///
///
///
/// Corresponds with the /template: flag.
///
///
[TaskAttribute("template", Required=false)]
public FileInfo TemplateFile {
get { return _templateFile; }
set { _templateFile = value; }
}
///
/// Specifies a string for the Title field in the assembly.
///
///
/// A string for the Title field in the assembly.
///
[TaskAttribute("title", Required=false)]
public string Title {
get { return _title; }
set { _title = value; }
}
///
/// Specifies a string for the Trademark field in the assembly.
///
///
/// A string for the Trademark field in the assembly.
///
[TaskAttribute("trademark", Required=false)]
public string Trademark {
get { return _trademark; }
set { _trademark = value; }
}
///
/// Specifies version information for the assembly. The format of the
/// version string is major.minor.build.revision.
///
[TaskAttribute("version", Required=false)]
public string Version {
get { return _version; }
set { _version = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Icon to associate with the assembly.
///
[TaskAttribute("win32icon", Required=false)]
public FileInfo Win32Icon {
get { return _win32Icon; }
set { _win32Icon = value; }
}
///
/// Inserts a Win32 resource (.res file) in the output file.
///
[TaskAttribute("win32res", Required=false)]
public FileInfo Win32Res {
get { return _win32Res; }
set { _win32Res = value; }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Gets the command-line arguments for the external program.
///
///
/// The command-line arguments for the external program or
/// if the task is not being executed.
///
public override string ProgramArguments {
get {
if (_responseFileName != null) {
return "@" + "\"" + _responseFileName + "\"";
} else {
return null;
}
}
}
///
/// Generates an assembly manifest.
///
protected override void ExecuteTask() {
// ensure base directory is set, even if fileset was not initialized
// from XML
if (Resources.BaseDirectory == null) {
Resources.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
// ensure base directory is set, even if fileset was not initialized
// from XML
if (ModuleSet.Dir == null) {
ModuleSet.Dir = new DirectoryInfo(Project.BaseDirectory);
}
if (NeedsCompiling()) {
// create temp response file to hold compiler options
_responseFileName = Path.GetTempFileName();
StreamWriter writer = new StreamWriter(_responseFileName);
try {
Log(Level.Info, ResourceUtils.GetString("String_CompilingFiles"),
Resources.FileNames.Count + EmbeddedResources.Count +
ModuleSet.Modules.Count, OutputFile.FullName);
// write modules to compile into assembly
foreach (Module module in ModuleSet.Modules) {
writer.WriteLine("\"{0}\"", module.ToString());
}
// write output target
writer.WriteLine("/target:\"{0}\"", OutputTarget);
// write output file
writer.WriteLine("/out:\"{0}\"", OutputFile.FullName);
// algorithm (in hexadecimal)
if (AlgorithmID != null) {
writer.WriteLine("/algid:\"{0}\"", AlgorithmID);
}
// company field
if (Company != null) {
writer.WriteLine("/company:\"{0}\"", Company);
}
// configuration field
if (Configuration != null) {
writer.WriteLine("/configuration:\"{0}\"", Configuration);
}
// copyright field
if (Copyright != null) {
writer.WriteLine("/copyright:\"{0}\"", Copyright);
}
// write culture associated with output assembly
if (Culture != null) {
writer.WriteLine("/culture:\"{0}\"", Culture);
}
// delay sign the assembly
switch (DelaySign) {
case DelaySign.NotSet:
break;
case DelaySign.Yes:
writer.WriteLine("/delaysign+");
break;
case DelaySign.No:
writer.WriteLine("/delaysign-");
break;
default:
throw new BuildException (string.Format (CultureInfo.InvariantCulture,
"Value {0} is not supported for \"delaysign\".",
DelaySign), Location);
}
// description field
if (Description != null) {
writer.WriteLine("/description:\"{0}\"", Description);
}
// write path to security evidence file
if (EvidenceFile != null) {
writer.WriteLine("/evidence:\"{0}\"", EvidenceFile.FullName);
}
// file version field
if (FileVersion != null) {
writer.WriteLine("/fileversion:\"{0}\"", FileVersion);
}
// flags field
if (Flags != null) {
writer.WriteLine("/flags:\"{0}\"", Flags);
}
// main method
if (MainMethod != null) {
writer.WriteLine("/main:\"{0}\"", MainMethod);
}
// keycontainer
if (KeyContainer != null) {
writer.WriteLine("/keyname:\"{0}\"", KeyContainer);
}
// product field
if (Product != null) {
writer.WriteLine("/product:\"{0}\"", Product);
}
// product version field
if (ProductVersion != null) {
writer.WriteLine("/productversion:\"{0}\"", ProductVersion);
}
// write path to template assembly
if (TemplateFile != null) {
if (SupportsTemplate) {
writer.WriteLine("/template:\"{0}\"", TemplateFile.FullName);
} else {
Log(Level.Warning,
ResourceUtils.GetString("String_LinkerDoesNotSupportTemplateAssembly"),
Project.TargetFramework.Description);
}
}
// title field
if (Title != null) {
writer.WriteLine("/title:\"{0}\"", Title);
}
// trademark field
if (Trademark != null) {
writer.WriteLine("/trademark:\"{0}\"", Trademark);
}
// key file
if (KeyFile != null) {
writer.WriteLine("/keyfile:\"{0}\"", KeyFile.FullName);
}
// assembly version
if (Version != null) {
writer.WriteLine("/version:\"{0}\"", Version);
}
// win32 icon
if (Win32Icon != null) {
writer.WriteLine("/win32icon:\"{0}\"", Win32Icon.FullName);
}
// win32 resource
if (Win32Res != null) {
writer.WriteLine("/win32res:\"{0}\"", Win32Res.FullName);
}
// write embedded resources to response file
foreach (string resourceFile in Resources.FileNames) {
writer.WriteLine("/embed:\"{0}\"", resourceFile);
}
// write embedded resources to response file
foreach (EmbeddedResource embeddedResource in EmbeddedResources) {
writer.WriteLine("/embed:\"{0}\",{1}", embeddedResource.File,
embeddedResource.ManifestResourceName);
}
// suppresses display of the sign-on banner
writer.WriteLine("/nologo");
// make sure to close the response file otherwise contents
// Will not be written to disk and ExecuteTask() will fail.
writer.Close();
if (Verbose) {
// display response file contents
Log(Level.Verbose, ResourceUtils.GetString("String_ContentsOf"), _responseFileName);
StreamReader reader = File.OpenText(_responseFileName);
Log(Level.Verbose, reader.ReadToEnd());
reader.Close();
}
// call base class to do the work
base.ExecuteTask();
} finally {
// make sure stream is closed or response file cannot be deleted
writer.Close();
// make sure we delete response file even if an exception is thrown
File.Delete(_responseFileName);
// initialize name of response file
_responseFileName = null;
}
}
}
#endregion Override implementation of ExternalProgramBase
#region Protected Instance Methods
///
/// Determines whether the assembly manifest needs compiling or is
/// uptodate.
///
///
/// if the assembly manifest needs compiling;
/// otherwise, .
///
protected virtual bool NeedsCompiling() {
if (!OutputFile.Exists) {
Log(Level.Verbose, ResourceUtils.GetString("String_OutputFileDoesNotExist"),
OutputFile.FullName);
return true;
}
string fileName = null;
// check if modules were updated
foreach (Module module in ModuleSet.Modules) {
fileName = FileSet.FindMoreRecentLastWriteTime(module.File, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
}
// check if (embedded)resources were updated
fileName = FileSet.FindMoreRecentLastWriteTime(Resources.FileNames, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
// check if evidence file was updated
if (EvidenceFile != null) {
fileName = FileSet.FindMoreRecentLastWriteTime(EvidenceFile.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
}
// check if template file was updated
if (TemplateFile != null) {
fileName = FileSet.FindMoreRecentLastWriteTime(TemplateFile.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
}
// check if key file was updated
if (KeyFile != null) {
fileName = FileSet.FindMoreRecentLastWriteTime(KeyFile.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
}
// check if win32 icon file was updated
if (Win32Icon != null) {
fileName = FileSet.FindMoreRecentLastWriteTime(Win32Icon.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
}
// check if win32 resource file was updated
if (Win32Res != null) {
fileName = FileSet.FindMoreRecentLastWriteTime(Win32Res.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
}
// check if embedded resource files were updated
foreach (EmbeddedResource embeddedResource in EmbeddedResources) {
fileName = FileSet.FindMoreRecentLastWriteTime(embeddedResource.File,
OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
}
// check the arguments for /embed or /embedresource options
StringCollection embeddedResourceFiles = new StringCollection();
foreach (Argument argument in Arguments) {
if (argument.IfDefined && !argument.UnlessDefined) {
string argumentValue = argument.Value;
// check whether argument specifies resource file to embed
if (argumentValue != null && (argumentValue.StartsWith("/embed:") || argumentValue.StartsWith("/embedresource:"))) {
// determine path to resource file
string path = argumentValue.Substring(argumentValue.IndexOf(':') + 1);
int indexOfComma = path.IndexOf(',');
if (indexOfComma != -1) {
path = path.Substring(0, indexOfComma);
}
bool isQuoted = path.Length > 2 && path.StartsWith("\"") && path.EndsWith("\"");
if (isQuoted) {
path = path.Substring(1, path.Length - 2);
}
// resolve path to full path (relative to project base dir)
path = Project.GetFullPath(path);
// add path to collection of resource files
embeddedResourceFiles.Add(path);
}
}
}
// check if embedded resources passed as arguments were updated
fileName = FileSet.FindMoreRecentLastWriteTime(embeddedResourceFiles, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
// if we made it here then we don't have to recompile
return false;
}
#endregion Protected Instance Methods
}
}
nant-0.92-rc1/src/NAnt.DotNet/NAnt.DotNet.csproj 0000644 0001750 0001750 00000013367 11757302273 021143 0 ustar jtaylor jtaylor
DebugAnyCPU2.0{B50A1067-785B-4686-8FFC-5AF424BEF163}NAnt.DotNetNAnt.DotNetTasksLibraryOnSuccessfulBuildfalse8.0.50727v2.02.0publish\trueDiskfalseForeground7Daysfalsefalsetrue01.0.0.%2afalsefalsetruetruefullfalse4..\..\build\Debug\AllRules.rulesetTRACE;DEBUG..\..\build\Debug\NAnt.DotNetTasks.xmltruepdbonlytrue..\..\build\Release\4AllRules.rulesetTRACE..\..\build\Release\NAnt.DotNetTasks.xml..\..\lib\common\neutral\NDoc.Core.dll
CommonAssemblyInfo.cs
False.NET Framework 3.5 SP1 Client ProfilefalseFalse.NET Framework 3.5 SP1trueFalseWindows Installer 3.1true{8F5F8375-4097-4952-B860-784EB9961ABE}NAnt.Core nant-0.92-rc1/src/NAnt.DotNet/NAnt.DotNet.build 0000644 0001750 0001750 00000003132 11757302273 020727 0 ustar jtaylor jtaylor
nant-0.92-rc1/src/NAnt.SourceControl/ 0000755 0001750 0001750 00000000000 11757310030 017245 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.SourceControl/AssemblyInfo.cs 0000644 0001750 0001750 00000002332 11757302274 022202 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Scott Hernandez (ScottHernandez@hotmail.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System.Reflection;
// This will not compile with Visual Studio. If you want to build a signed
// executable use the NAnt build file. To build under Visual Studio just
// exclude this file from the build.
[assembly: AssemblyDelaySign(false)]
//[assembly: AssemblyKeyFile(@"..\NAnt.key")]
[assembly: AssemblyKeyName("")] nant-0.92-rc1/src/NAnt.SourceControl/Types/ 0000755 0001750 0001750 00000000000 11757310030 020351 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.SourceControl/Types/CvsFileSet.cs 0000644 0001750 0001750 00000007425 11757302274 022732 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2005 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Clayton Harbour (claytonharbour@sporadicism.com)
using System;
using System.Collections;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.SourceControl.Tasks;
namespace NAnt.SourceControl.Types {
///
/// A is a with extra
/// attributes useful in the context of the .
///
[ElementName("cvsfileset")]
public class CvsFileSet : FileSet {
#region Private Instance Fields
private bool _useCvsIgnore = true;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Indicates whether the entires in the .cvsignore should be used to limit the
/// file list; to exclude files in .cvsignore, otherwise
/// . The default is .
///
[TaskAttribute("usecvsignore", Required=false)]
public bool UseCvsIgnore{
get { return this._useCvsIgnore; }
set { this._useCvsIgnore = value; }
}
#endregion Public Instance Properties
#region Override Implementation of Element
///
/// Initialize the object and locate the .cvsignore
/// files to add to the exclude list.
///
protected override void Initialize() {
if (UseCvsIgnore) {
ArrayList ignoreFiles = new ArrayList();
this.ScanCvsIgnores(base.BaseDirectory, ignoreFiles);
foreach (string ignoreFile in ignoreFiles) {
Excludes.Add(ignoreFile);
}
}
base.Initialize();
}
#endregion Override Implementation of Element
#region Private Instance Methods
private void ScanCvsIgnores(DirectoryInfo dir, ArrayList ignoreFiles) {
foreach (FileInfo file in dir.GetFiles("*.cvsignore")) {
AddCvsIgnores(file, ignoreFiles);
}
foreach (DirectoryInfo subDir in dir.GetDirectories()) {
this.ScanCvsIgnores(subDir, ignoreFiles);
}
}
private void AddCvsIgnores(FileInfo file, ArrayList ignoreFiles) {
using (StreamReader reader = new StreamReader(file.FullName)) {
string line;
while ((line = reader.ReadLine()) != null) {
// if the .cvsignore is at the start of the file then
// exclude a *.[extension] pattern
if (line.IndexOf(".") == 0) {
ignoreFiles.Add(Path.Combine(file.DirectoryName, "*" + line));
} else {
ignoreFiles.Add(Path.Combine(file.DirectoryName, line));
}
}
}
}
#endregion Private Instance Methods
}
}
nant-0.92-rc1/src/NAnt.SourceControl/NAnt.SourceControl.build 0000644 0001750 0001750 00000002710 11757302274 023741 0 ustar jtaylor jtaylor
nant-0.92-rc1/src/NAnt.SourceControl/Tasks/ 0000755 0001750 0001750 00000000000 11757310030 020332 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.SourceControl/Tasks/CheckoutTask.cs 0000644 0001750 0001750 00000014327 11757302274 023273 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Clayton Harbour (claytonharbour@sporadicism.com)
using System;
using System.Globalization;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
namespace NAnt.SourceControl.Tasks {
///
/// Checks out a CVS module to the required directory.
///
///
/// Checkout NAnt.
///
///
/// ]]>
///
///
///
///
/// Checkout NAnt revision named 0_85 to the
/// folder c:\src\nant\v0.85.
///
///
///
/// ]]>
///
/// So the nant module tagged with revision 0_85 will be checked
/// out in the folder v0.85 under the working/ destination directory.
/// This could be used to work on different
/// branches of a repository at the same time.
///
///
///
/// Checkout NAnt with specified revision date to the
/// folder c:\src\nant\2003_08_16.
///
///
///
/// ]]>
///
///
[TaskName("cvs-checkout")]
public class CheckoutTask : AbstractCvsTask {
#region Internal Static Fields
///
/// The command being executed.
///
internal const string CvsCommandName = "checkout";
#endregion Internal Static Fields
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public CheckoutTask() {
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Specify the revision to checkout. This corresponds to the "sticky-tag"
/// of the file.
///
[TaskAttribute("revision", Required=false)]
[StringValidator(AllowEmpty=true, Expression=@"^[A-Za-z0-9][A-Za-z0-9._\-]*$")]
public string Revision {
get {
if (CommandOptions.ContainsKey("revision")) {
return ((Option)CommandOptions["revision"]).Value;
}
return null;
}
set {
if (String.IsNullOrEmpty(value)) {
CommandOptions.Remove("revision");
} else {
SetCommandOption("revision", string.Format(CultureInfo.InvariantCulture,
"-r {0}", value), true);
}
}
}
///
/// Sticky tag or revision to checkout.
///
[TaskAttribute("sticky-tag", Required=false)]
[StringValidator(AllowEmpty=true, Expression=@"^[A-Za-z0-9][A-Za-z0-9._\-]*$")]
public string StickyTag {
get { return Revision; }
set { Revision = value; }
}
///
/// Specify the revision date to checkout. The date specified is validated
/// and then passed to the cvs binary in a standard format recognized by
/// cvs.
///
[TaskAttribute("date", Required=false)]
[DateTimeValidator()]
public DateTime Date {
get { return Convert.ToDateTime(((Option)CommandOptions["date"]).Value); }
set { SetCommandOption("date", String.Format(CultureInfo.InvariantCulture,"-D \"{0}\"", ToCvsDateTimeString(value)), true); }
}
///
/// Specify a directory name to replace the module name. Valid names
/// include any valid filename, excluding path information.
///
[TaskAttribute("overridedir", Required=false)]
[StringValidator(AllowEmpty=false)]
public string OverrideDir {
get { return ((Option)CommandOptions["overridedir"]).Value; }
set { SetCommandOption("overridedir", String.Format(CultureInfo.InvariantCulture,"-d{0}", value), true); }
}
///
/// Specify a directory name to replace the module name. Valid names
/// include any valid filename, excluding path information.
///
[TaskAttribute("override-directory", Required=false)]
public string OverrideDirectory {
get { return OverrideDir; }
set { OverrideDir = value; }
}
#endregion
#region Override implementation of AbstractCvsTask
///
/// The name of the cvs command that is going to be executed.
///
public override string CommandName {
get { return CvsCommandName; }
}
#endregion Override implementation of AbstractCvsTask
}
}
nant-0.92-rc1/src/NAnt.SourceControl/Tasks/AbstractSourceControlTask.cs 0000644 0001750 0001750 00000044510 11757302274 026010 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Clayton Harbour (claytonharbour@sporadicism.com)
using System;
using System.Collections;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Globalization;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
namespace NAnt.SourceControl.Tasks {
///
/// A base class for creating tasks for executing CVS client commands on a
/// CVS repository.
///
public abstract class AbstractSourceControlTask : ExternalProgramBase {
#region Protected Static Fields
///
/// Name of the environmental variable specifying a users' home
/// in a *nix environment.
///
protected const String EnvHome = "HOME";
///
/// Used on windows to specify the location of application data.
///
protected const string AppData = "APPDATA";
///
/// The environment variable that holds path information.
///
protected const String PathVariable = "PATH";
///
/// The environment variable that holds the location of the
/// .cvspass file.
///
protected const string CvsPassFileVariable = "CVS_PASSFILE";
///
/// Property name used to specify the source control executable. This is
/// used as a readonly property.
///
protected const string PropExeName = "sourcecontrol.exename";
#endregion
#region Private Instance Fields
private string _exeName;
private string _root;
private DirectoryInfo _destinationDirectory;
private string _password;
private FileInfo _passFile;
private string _commandName;
private string _commandLine = null;
private Hashtable _commandOptions = new Hashtable();
private string _commandLineArguments;
private Hashtable _globalOptions = new Hashtable();
private FileInfo _ssh;
private FileSet _fileset = new FileSet();
#endregion Private Instance Fields
#region Private Static Fields
private static readonly log4net.ILog Logger =
log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
#endregion Private Static Fields
#region Protected Instance Constructors
///
/// Initializes a new instance of the
/// class.
///
protected AbstractSourceControlTask () : base() {
}
#endregion Protected Instance Constructors
#region Protected Instance Properties
///
/// The name of the passfile, overriden for each version control system (VCS).
///
protected abstract string PassFileName {get;}
///
/// The path to the specific home directory of the version control system,
/// this can be where the binary files are kept, or other app
/// information.
///
protected DirectoryInfo VcsHome {
get {
string vcsHome =
Environment.GetEnvironmentVariable(VcsHomeEnv);
if (null != vcsHome) {
if (Directory.Exists(vcsHome)) {
return new DirectoryInfo(vcsHome);
}
}
return null;
}
}
///
/// The environment variable that defines where the version control system
/// (VCS) home variable is kept.
///
protected abstract string VcsHomeEnv {get;}
///
/// The name of the version control system (VCS) executable file.
///
protected abstract string VcsExeName {get;}
#endregion
#region Public Instance Properties
///
///
/// The root variable contains information on how to locate a repository.
/// Although this information is in different formats it typically must
/// define the following:
///
/// server location
/// protocol used to communicate with the repository
/// repository location on the server
/// project location in the repository
///
///
///
[StringValidator(AllowEmpty=false)]
public virtual string Root {
get {return _root;}
set {_root = value;}
}
///
/// Destination directory for the local sandbox. If destination is not specified
/// then the current directory is used.
///
///
/// Root path of the local sandbox.
///
///
///
/// Root path of the local sandbox.
///
///
[TaskAttribute("destination", Required=false)]
public virtual DirectoryInfo DestinationDirectory {
get {
if (null == this._destinationDirectory) {
this._destinationDirectory = new DirectoryInfo(Environment.CurrentDirectory);
}
return this._destinationDirectory;
}
set { this._destinationDirectory = value; }
}
///
/// The password for logging in to the repository.
///
///
/// The password for logging in to the repository.
///
[TaskAttribute("password", Required=false)]
[Obsolete("Use task instead.", true)]
public virtual string Password {
get { return _password;}
set { _password = StringUtils.ConvertEmptyToNull(value); }
}
///
/// The full path to the cached password file. If not specified then the
/// environment variables are used to try and locate the file.
///
[TaskAttribute("passfile")]
public virtual FileInfo PassFile {
get { return _passFile; }
set { _passFile = value; }
}
///
/// Holds a collection of globally available options.
///
public Hashtable GlobalOptions {
get {return _globalOptions;}
set {_globalOptions = value;}
}
///
/// A collection of options that can be used to modify the default behavoir
/// of the version control commands. See the sub-tasks for implementation
/// specifics.
///
public Hashtable CommandOptions {
get { return _commandOptions;}
set { _commandOptions = value; }
}
///
/// Command-line arguments for the program. The command line arguments are used to specify
/// any cvs command options that are not available as attributes. These are appended
/// after the command itself and are additive to whatever attributes are currently specified.
///
///
/// <cvs-checkout cvsroot=":pserver:anonymous@cvs.sourceforge.net:/cvsroot/nant"
/// module="nant"
/// destination="e:\test\merillcornish\working"
/// readonly="true"
/// quiet="true"
/// commandline="-n"
/// cvsfullpath="C:\Program Files\TortoiseCVS\cvs.exe"
/// />
///
/// Produces the cvs command:
/// c:\Program Files\TortoiseCVS\cvs.exe -d:pserver:anonymous@cvs.sourceforge.net:/cvsroot/nant -q checkout -n nant
///
[TaskAttribute("commandline")]
public string CommandLineArguments {
get {return _commandLineArguments;}
set {_commandLineArguments = StringUtils.ConvertEmptyToNull(value);}
}
///
/// The name of the command that is going to be executed.
///
public virtual string CommandName {
get {return _commandName;}
set {_commandName = value;}
}
///
/// Used to specify the version control system (VCS) files that are going
/// to be acted on.
///
[BuildElement("fileset")]
public virtual FileSet VcsFileSet {
get { return _fileset; }
set { _fileset = value; }
}
///
/// The executable to use for ssh communication.
///
[TaskAttribute("ssh", Required=false)]
public virtual FileInfo Ssh {
get {return _ssh;}
set {_ssh = value;}
}
#endregion Public Instance Properties
#region Protected Instance Properties
///
/// The environment name for the ssh variable.
///
protected abstract string SshEnv {
get;
}
#endregion Protected Instance Properties
#region Override implementation of ExternalProgramBase
///
/// The name of the version control system executable.
///
public override string ExeName {
get {return _exeName;}
set {_exeName = value;}
}
///
/// Get the command line arguments for the task.
///
public override string ProgramArguments {
get {return _commandLine;}
}
///
/// Build up the command line arguments, determine which executable is being
/// used and find the path to that executable and set the working
/// directory.
///
/// The process to prepare.
protected override void PrepareProcess (Process process) {
base.PrepareProcess(process);
SetEnvironment(process);
}
#endregion Override implementation of ExternalProgramBase
#region Protected Instance Methods
///
/// Adds a new global option if none exists. If one does exist then
/// the use switch is toggled on or of.
///
/// The common name of the option.
/// The option value or command line switch
/// of the option.
/// true if the option should be
/// appended to the commandline, otherwise false.
protected void SetGlobalOption (String name, String value, bool on) {
Option option;
Log(Level.Debug, "Name: {0}", name);
Log(Level.Debug, "Value: {0}",value);
Log(Level.Debug, "On: {0}", on);
if (GlobalOptions.Contains(name)) {
option = (Option)GlobalOptions[name];
} else {
option = new Option();
option.OptionName = name;
option.Value = value;
GlobalOptions.Add(option.OptionName, option);
}
option.IfDefined = on;
}
///
/// Adds a new command option if none exists. If one does exist then
/// the use switch is toggled on or of.
///
/// The common name of the option.
/// The option value or command line switch
/// of the option.
/// true if the option should be
/// appended to the commandline, otherwise false.
protected void SetCommandOption (String name, String value, bool on) {
Option option;
if (CommandOptions.Contains(name)) {
option = (Option)CommandOptions[name];
} else {
option = new Option();
option.OptionName = name;
option.Value = value;
CommandOptions.Add(name, option);
}
option.IfDefined = on;
}
///
/// Set up the environment variables for a process.
///
/// A process to setup.
protected virtual void SetEnvironment (Process process) {
if (Ssh != null && !Ssh.Exists) {
FileInfo tempLookup = DeriveFullPathFromEnv(PathVariable, Ssh.Name);
if (null == tempLookup) {
tempLookup = DeriveFullPathFromEnv(PathVariable, Ssh.Name + ".exe");
}
if (null != tempLookup) {
Ssh = tempLookup;
}
}
if (Ssh != null) {
try {
process.StartInfo.EnvironmentVariables.Add(SshEnv, Ssh.FullName);
} catch (System.ArgumentException e) {
Logger.Warn("Possibility cvs_rsh key has already been added.", e);
}
}
if (null != this.PassFile) {
if (process.StartInfo.EnvironmentVariables.ContainsKey(CvsPassFileVariable)) {
process.StartInfo.EnvironmentVariables[CvsPassFileVariable] = this.PassFile.FullName;
} else {
process.StartInfo.EnvironmentVariables.Add(CvsPassFileVariable, PassFile.FullName);
}
}
Log(Level.Verbose, "Using ssh binary: {0}", process.StartInfo.EnvironmentVariables[SshEnv]);
Log(Level.Verbose, "Using .cvspass file: {0}", process.StartInfo.EnvironmentVariables[CvsPassFileVariable]);
}
///
/// Append the files specified in the fileset to the command line argument.
/// Files are changed to use a relative path from the working directory
/// that the task is spawned in.
///
protected void AppendFiles () {
foreach (string pathname in VcsFileSet.FileNames) {
string relativePath = pathname.Replace(DestinationDirectory.FullName, "");
if (relativePath.IndexOf('/') == 0 || relativePath.IndexOf('\\') == 0) {
relativePath = relativePath.Substring(1, relativePath.Length - 1);
}
relativePath = relativePath.Replace("\\", "/");
Arguments.Add(new Argument("\"" + relativePath + "\""));
}
}
///
/// Derive the location of the version control system from the environment
/// variable PATH.
///
/// The file information of the version control system,
/// or null if this cannot be found.
protected FileInfo DeriveVcsFromEnvironment () {
FileInfo vcsFile =
DeriveFullPathFromEnv(VcsHomeEnv, VcsExeName);
if (null == vcsFile) {
vcsFile = DeriveFullPathFromEnv(PathVariable, VcsExeName);
}
return vcsFile;
}
#endregion Protected Instance Methods
#region Private Instance Methods
private FileInfo DeriveFullPathFromEnv(string environmentVar, string fileName) {
string environmentValue = StringUtils.ConvertEmptyToNull(
System.Environment.GetEnvironmentVariable(environmentVar));
Log(Level.Debug, "Environment variable: {0}", environmentVar);
Log(Level.Debug, "Environment value: {0}", environmentValue);
if (environmentValue != null) {
string[] environmentPaths = environmentValue.Split(Path.PathSeparator);
foreach (string environmentPath in environmentPaths) {
if (environmentPath == null) {
continue;
}
// remove leading or trailing quotes, which are valid for
// individual entries in PATH but are considered invalid
// path characters
string cleanPath = environmentPath.Trim('\"');
Log(Level.Debug, "Environment Path: {0}", cleanPath);
Log(Level.Debug, "FileName: {0}", fileName);
string fileFullName = Path.Combine(cleanPath, fileName);
Log(Level.Debug, "FileFullName: {0}", fileFullName);
if (environmentPath.IndexOf(fileName) > -1 && File.Exists(fileName)) {
if (!(Path.GetDirectoryName(fileName).IndexOf(
Path.GetDirectoryName(System.AppDomain.CurrentDomain.BaseDirectory)) > 1)) {
return new FileInfo(fileName);
}
}
if (fileFullName.IndexOf(fileName) > -1 && File.Exists(fileFullName)) {
if (Path.GetDirectoryName(fileFullName).IndexOf(
Path.GetDirectoryName(System.AppDomain.CurrentDomain.BaseDirectory)) == -1) {
return new FileInfo(fileFullName);
}
}
}
}
return null;
}
#endregion Private Instance Methods
}
} nant-0.92-rc1/src/NAnt.SourceControl/Tasks/CvsPass.cs 0000644 0001750 0001750 00000011562 11757302274 022263 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Clayton Harbour (claytonharbour@sporadicism.com)
using System;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
namespace NAnt.SourceControl.Tasks {
///
/// Executes the cvs login command which appends or updates an entry to the
/// specified .cvspass file.
///
///
/// Update .cvspass file to include the NAnt anonymous login.
///
///
/// ]]>
///
///
[TaskName("cvs-pass")]
public class CvsPass : Task {
#region Private Instance Fields
private string _password;
private FileInfo _passFile;
private string _cvsRoot;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Password to append or update to the .cvspass file.
///
[TaskAttribute("password", Required=true)]
public string Password {
get { return _password; }
set { _password = value; }
}
///
/// The full path to the .cvspass file. The default is ~/.cvspass.
///
///
[TaskAttribute("passfile", Required=false)]
public FileInfo PassFile {
get { return this._passFile; }
set { this._passFile = value; }
}
///
/// The current working directory.
///
public virtual DirectoryInfo DestinationDirectory {
get { return new DirectoryInfo(Environment.CurrentDirectory); }
}
///
/// The repository root string.
///
[TaskAttribute("cvsroot", Required=false)]
[StringValidator(AllowEmpty=false)]
public string Root {
get { return this._cvsRoot; }
set { this._cvsRoot = value; }
}
#endregion Public Instance Properties
#region Override implementation of Task
///
/// Ensures all information is available to execute the .
///
protected override void Initialize() {
// ensure passfile was either set by user or could be discovered from
// environment or located in HOME directory
if (PassFile == null) {
throw new BuildException("'passfile' was not explicitly specified"
+ " and could not be determined from environment, or found in"
+ " home directory.", Location);
}
}
///
/// Update the .cvspass file with the given password. If the passfile
/// is not specified then the default search locations are used:
///
/// CVS_PASSFILE/.cvspass
/// HOME/.cvspass
/// USERPROFILE/.cvspass TODO: Confirm that this is valid
/// behavior or if it is going to give problems with the
/// cvsnt implementation.
///
///
protected override void ExecuteTask () {
ICSharpCode.SharpCvsLib.FileSystem.Manager manager =
new ICSharpCode.SharpCvsLib.FileSystem.Manager(this.DestinationDirectory);
if (this.PassFile == null) {
manager.UpdatePassFile(this.Password,
new ICSharpCode.SharpCvsLib.Misc.CvsRoot(this.Root));
} else {
Log(Level.Verbose, "Updating .cvspass file '{0}'.", this.PassFile.FullName);
manager.UpdatePassFile(this.Password,
new ICSharpCode.SharpCvsLib.Misc.CvsRoot(this.Root), this.PassFile);
}
}
#endregion Override implementation of Task
}
}
nant-0.92-rc1/src/NAnt.SourceControl/Tasks/CvsTask.cs 0000644 0001750 0001750 00000005472 11757302274 022262 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Clayton Harbour (claytonharbour@sporadicism.com)
using NAnt.Core.Attributes;
namespace NAnt.SourceControl.Tasks {
///
/// Executes the cvs command specified by the command attribute.
///
///
/// Checkout NAnt.
///
///
/// ]]>
///
///
[TaskName("cvs")]
public class CvsTask : AbstractCvsTask {
#region Private Instance Fields
private string _commandName;
#endregion Private Instance Fields
#region Override implementation of AbstractCvsTask
///
/// The cvs command to execute.
///
[TaskAttribute("command", Required=true)]
public override string CommandName {
get { return _commandName; }
set { _commandName = value; }
}
///
/// Specify if the module is needed for this cvs command.
///
protected override bool IsModuleNeeded {
get {
bool moduleNeeded;
switch (this.CommandName) {
case CheckoutTask.CvsCommandName:
moduleNeeded = true;
break;
case UpdateTask.CvsCommandName:
moduleNeeded = false;
break;
case "commit":
moduleNeeded = false;
break;
case TagTask.CvsCommandName:
moduleNeeded = false;
break;
default:
moduleNeeded = true;
break;
}
return moduleNeeded;
}
}
#endregion Override implementation of AbstractCvsTask
}
}
nant-0.92-rc1/src/NAnt.SourceControl/Tasks/RTagTask.cs 0000644 0001750 0001750 00000020313 11757302274 022353 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Clayton Harbour (claytonharbour@sporadicism.com)
using System;
using System.Globalization;
using NAnt.Core.Tasks;
using NAnt.Core.Attributes;
using NAnt.Core.Util;
using NAnt.Core.Types;
namespace NAnt.SourceControl.Tasks {
///
/// Tags all sources in the remote repository with a given tag.
///
///
///
/// Unlike tag, the rtag command acts only on sources that are in the repository.
/// Any modified sources on the local file system will NOT be tagged with this
/// command, so a commit should be performed before an rtag is done.
///
///
/// NOTE: Although a working directory is not necessary to perform the command
/// one must be specified in order to remain in compliance with the cvs library.
///
///
///
/// Tag NAnt sources remotely.
///
///
/// ]]>
///
///
///
/// Remove a tag from the remote repository.
///
///
/// ]]>
///
///
[TaskName("cvs-rtag")]
public class RTagTask : AbstractCvsTask {
#region Private Instance Fields
private string _tag;
#endregion Private Instance Fields
#region Private Static Fields
private const string CvsCommandName = "rtag";
#endregion Private Static Fields
#region Public Instance Constructors
///
/// Initializes a new instance of the
/// class.
///
public RTagTask() {
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// The name of the tag to assign or remove.
///
///
/// The name of the tag to assign or remove.
///
[TaskAttribute("tag", Required=true)]
[StringValidator(AllowEmpty=false, Expression=@"^[A-Za-z0-9][A-Za-z0-9._\-]*$")]
public string Tag {
get { return this._tag; }
set { this._tag = value; }
}
///
/// Indicates whether the tag specified in should
/// be removed or not.
///
///
/// if the specified tag should be removed;
/// otherwise, . The default is .
///
[TaskAttribute("remove", Required=false)]
[BooleanValidator()]
public bool Remove {
get { return ((Option)CommandOptions["remove"]).IfDefined; }
set { SetCommandOption("remove", "-d", value); }
}
///
/// Indicates whether the tag specified in should
/// be moved to the current file revision. If the tag does not exist
/// then it is created.
///
///
/// if the specified tag should be moved;
/// otherwise, . The default is .
///
[TaskAttribute("move-if-exists", Required=false)]
[BooleanValidator()]
public bool MoveIfExists {
get { return ((Option)CommandOptions["move-if-exists"]).IfDefined; }
set { SetCommandOption("move-if-exists", "-F", value); }
}
///
/// If a directory is specified indicates whether sub-directories should
/// also be processed.
///
///
/// if the sub-directories should be tagged;
/// otherwise, . The default is .
///
[TaskAttribute("recursive", Required=false)]
[BooleanValidator()]
public bool Recursive {
get { return ((Option)CommandOptions["recursive"]).IfDefined; }
set {
SetCommandOption("recursive", "-R", value);
SetCommandOption("local-only", "-l", !value);
}
}
///
/// Indicates the repository that is acted on
/// for the tag command. Note if is
/// then the tag specified is moved to the revision
/// of the file on the HEAD of the branch specified.
///
///
/// The tag (or more likely) branch that should be used to apply the new tag.
///
[TaskAttribute("act-on-tag", Required=false)]
[StringValidator(AllowEmpty=false, Expression=@"^[A-Za-z0-9][A-Za-z0-9._\-]*$")]
public string ActOnTag {
get { return ((Option)CommandOptions["act-on-tag"]).Value; }
set { SetCommandOption("act-on-tag", String.Format(CultureInfo.InvariantCulture,"-r {0}", value), true); }
}
///
/// Indicates the revision date of the file that the tag should be
/// applied to.
///
///
/// A valid date which specifies the revision point that the tag will
/// be applied to.
///
[TaskAttribute("act-on-date", Required=false)]
[DateTimeValidator()]
public DateTime ActOnDate {
get { return Convert.ToDateTime(((Option)CommandOptions["act-on-date"]).Value); }
set { SetCommandOption("act-on-date", String.Format(CultureInfo.InvariantCulture,"-D {0}", ToCvsDateTimeString(value)), true); }
}
///
/// Indicates whether the head revision should be used if the
/// or the tags are not
/// found.
///
///
/// if the specified tag should be moved;
/// otherwise, . The default is .
///
[TaskAttribute("force-head", Required=false)]
[BooleanValidator()]
public bool ForceHead {
get { return ((Option)CommandOptions["force-head"]).IfDefined; }
set { SetCommandOption("force-head", "-f", value); }
}
#endregion Public Instance Properties
#region Override implementation of AbstractCvsTask
///
/// The name of the cvs command that is going to be executed.
///
public override string CommandName {
get {return CvsCommandName;}
}
///
/// Append the tag information to the commandline.
///
protected override void AppendSubCommandArgs() {
base.AppendSubCommandArgs ();
if (this.Tag != null && this.Tag != string.Empty) {
this.AddArg(this.Tag);
}
}
#endregion Override implementation of AbstractCvsTask
}
}
nant-0.92-rc1/src/NAnt.SourceControl/Tasks/ExportTask.cs 0000644 0001750 0001750 00000017060 11757302274 023004 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Clayton Harbour (claytonharbour@sporadicism.com)
using System;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.Globalization;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
namespace NAnt.SourceControl.Tasks {
///
/// Exports a cvs module in preperation for a release (i.e. the CVS version
/// folders are not exported).
///
///
/// Export the most recent NAnt sources from cvs.
///
///
/// ]]>
///
///
///
///
/// Export NAnt revision named your_favorite_revision_here to the
/// folder c:\src\nant\replacement_for_module_directory_name.
///
/// **NOTE**: filesets names for the export task must be
/// prefixed with the module name. This is different than other tasks.
///
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("cvs-export")]
public class ExportTask : AbstractCvsTask {
#region Private Static Fields
///
/// The command being executed.
///
private const string CvsCommandName = "export";
#endregion Private Static Fields
#region Public Instance Constructors
///
/// Create a new instance of the .
///
///
/// The following values are set by default:
///
///
Recursive:
///
///
public ExportTask() {
Recursive = true;
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// No shortening. Do not shorten module paths if -d specified.
///
[TaskAttribute("no-shortening", Required=false)]
[BooleanValidator()]
public bool NoShortening {
get { return ((Option)CommandOptions["no-shortening"]).IfDefined; }
set { SetCommandOption("no-shortening", "-N", value); }
}
///
/// Indicates whether the head revision should be used if the revison specified by
/// or the tags are not
/// found. The default is .
///
///
/// if the specified tag should be moved;
/// otherwise, . The default is .
///
[TaskAttribute("force-head", Required=false)]
[BooleanValidator()]
public bool ForceHead {
get { return ((Option)CommandOptions["force-head"]).IfDefined; }
set { SetCommandOption("force-head", "-f", value); }
}
///
/// If a directory is specified indicates whether sub-directories should
/// also be processed.
///
///
/// if the sub-directories should be tagged;
/// otherwise, . The default is .
///
[TaskAttribute("recursive", Required=false)]
[BooleanValidator()]
public bool Recursive {
get { return ((Option)CommandOptions["recursive"]).IfDefined; }
set {
SetCommandOption("recursive", "-R", value);
SetCommandOption("local-only", "-l", !value);
}
}
///
/// Specify the revision to update the file to. This corresponds to the "sticky-tag"
/// of the file.
///
[TaskAttribute("revision", Required=false)]
[StringValidator(AllowEmpty=true, Expression=@"^[A-Za-z0-9][A-Za-z0-9._\-]*$")]
public string Revision {
get {
if (null == CommandOptions["revision"]) {
return null;
}
return ((Option)CommandOptions["revision"]).Value;}
set {
if (String.IsNullOrEmpty(value)) {
CommandOptions.Remove("revision");
} else {
SetCommandOption("revision", string.Format(CultureInfo.InvariantCulture,
"-r {0}", value), true);
}
}
}
///
/// Specify the revision date to update to. The version of the file that
/// existed at the date specified is retrieved.
///
///
/// A valid date time value, which is then converted to a format that
/// cvs can parse.
///
[TaskAttribute("date", Required=false)]
[DateTimeValidator()]
public DateTime Date {
get { return Convert.ToDateTime(((Option)CommandOptions["date"]).Value); }
set { SetCommandOption("date", String.Format(CultureInfo.InvariantCulture,"\"-D {0}\"", ToCvsDateTimeString(value)), true); }
}
///
/// Specify a directory name to replace the module name. Valid names
/// include any valid filename, excluding path information.
///
[TaskAttribute("overridedir", Required=false)]
[StringValidator(AllowEmpty=false, Expression=@"^[A-Za-z0-9][A-Za-z0-9._\-]*$")]
public string OverrideDir {
get { return ((Option)CommandOptions["overridedir"]).Value; }
set { SetCommandOption("overridedir", String.Format(CultureInfo.InvariantCulture,"-d{0}", value), true); }
}
#endregion Public Instance Properties
#region Override implementation of AbstractCvsTask
///
/// The export command name for the cvs client.
///
public override string CommandName {
get { return CvsCommandName; }
}
#endregion Override implementation of AbstractCvsTask
}
}
nant-0.92-rc1/src/NAnt.SourceControl/Tasks/ChangeLogTask.cs 0000644 0001750 0001750 00000014344 11757302274 023354 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Clayton Harbour (claytonharbour@sporadicism.com)
using System;
using System.Globalization;
using System.IO;
using System.Text;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
namespace NAnt.SourceControl.Tasks {
///
/// Produces an XML report that represents the cvs changes from the given
/// start day, to a given end date.
///
///
/// Report changes in NAnt from 1st of June 2004 until 25th of July 2004.
///
///
/// ]]>
///
///
[TaskName("cvs-changelog")]
public class ChangeLogTask : AbstractCvsTask {
#region Private Static Fields
///
/// The command being executed.
///
private const string CvsCommandName = "xml";
#endregion Private Static Fields
#region Public Instance Properties
///
/// Name of the xml file that will contain the cvs log information.
///
[TaskAttribute("xmlfile", Required=true)]
public FileInfo DestFile {
get {
if (!CommandOptions.ContainsKey("destfile")) {
return null;
}
return new FileInfo(((Option) CommandOptions["destfile"]).Value);
}
set {
if (null == this.DestinationDirectory) {
this.DestinationDirectory =
new DirectoryInfo(value.DirectoryName);
}
SetCommandOption("destfile", string.Format(CultureInfo.InvariantCulture,
"\"-oxml\" \"{0}\"", value.FullName), true);
}
}
///
/// The earliest change to use in the cvs log command.
///
[TaskAttribute("start", Required=true)]
[DateTimeValidator()]
public DateTime StartDate {
get { return Convert.ToDateTime(((Option)CommandOptions["start"]).Value); }
set { SetCommandOption("start", string.Format(CultureInfo.InvariantCulture,"-D \"{0}\"", ToCvsDateTimeString(value)), true); }
}
///
/// The latest date to use in the cvs log command.
///
[TaskAttribute("end", Required=true)]
[DateTimeValidator()]
public DateTime EndDate {
get { return Convert.ToDateTime(((Option)CommandOptions["end"]).Value); }
set { SetCommandOption("end", string.Format(CultureInfo.InvariantCulture,"-D \"{0}\"", ToCvsDateTimeString(value)), true); }
}
#endregion Public Instance Properties
#region Override implementation of AbstractCvsTask
///
/// The cvs command to execute.
///
public override string CommandName {
get { return CvsCommandName; }
}
///
/// Override use of sharpcvslib, needs to be true.
///
public override bool UseSharpCvsLib {
get { return true; }
set { /* can only use sharpcvslib for changelog */ }
}
///
///
/// The cvs root variable has the following components:
///
///
/// [protocol]:[username]@[servername]:[server path]
///
///
protocol: ext, pserver, ssh (sharpcvslib); if you are not using sharpcvslib consult your cvs documentation.
///
username: [username]
///
servername: cvs.sourceforge.net
///
server path: /cvsroot/nant
///
///
///
/// If the cvsroot is not specified then the directory specified by the
/// attribute
/// is searched for CVS\Root.
///
///
///
/// NAnt anonymous cvsroot:
///
/// :pserver:anonymous@cvs.sourceforge.net:/cvsroot/nant
///
///
[TaskAttribute("cvsroot", Required=false)]
public override string Root {
get {
if (null == base.Root && this.DestinationDirectory.Exists) {
try {
ICSharpCode.SharpCvsLib.FileSystem.Manager manager =
new ICSharpCode.SharpCvsLib.FileSystem.Manager(this.DestinationDirectory.FullName);
ICSharpCode.SharpCvsLib.FileSystem.Root root =
manager.FetchRoot(this.DestinationDirectory.FullName);
base.Root = root.FileContents;
} catch (Exception e) {
throw new BuildException (e.Message);
}
}
return base.Root;
}
set { base.Root = value; }
}
#endregion Override implementation of AbstractCvsTask
}
}
nant-0.92-rc1/src/NAnt.SourceControl/Tasks/TagTask.cs 0000644 0001750 0001750 00000022660 11757302274 022240 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Clayton Harbour (claytonharbour@sporadicism.com)
using System;
using System.Globalization;
using NAnt.Core.Tasks;
using NAnt.Core.Attributes;
using NAnt.Core.Util;
using NAnt.Core.Types;
namespace NAnt.SourceControl.Tasks {
///
/// Tags all local sources with the specified tag.
///
///
///
/// This differs from the
/// in that it acts on references to the cvs files
/// contained in your local filesystem. As such the sticky tags and local
/// revisions can be considered in commits. It also allows you to verify that
/// all local files have been checked in before a tag is performed.
///
///
///
/// Tag NAnt sources remotely.
///
///
/// ]]>
///
///
///
/// Remove a tag from the remote repository.
///
///
/// ]]>
///
///
[TaskName("cvs-tag")]
public class TagTask : AbstractCvsTask {
#region Private Instance Fields
private string _tag;
#endregion Private Instance Fields
#region Internal Static Fields
///
/// Cvs command to be executed.
///
internal const string CvsCommandName = "tag";
#endregion Internal Static Fields
#region Public Instance Constructors
///
/// Initializes a new instance of the
/// class.
///
public TagTask() {
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// The name of the tag to assign or remove.
///
///
/// The name of the tag to assign or remove.
///
[TaskAttribute("tag", Required=true)]
[StringValidator(AllowEmpty=false, Expression=@"^[A-Za-z0-9][A-Za-z0-9._\-]*$")]
public string Tag {
get { return this._tag; }
set { this._tag = value; }
}
///
/// Indicates whether the tag specified in should
/// be removed or not.
///
///
/// if the specified tag should be removed;
/// otherwise, . The default is .
///
[TaskAttribute("remove", Required=false)]
[BooleanValidator()]
public bool Remove {
get { return ((Option)CommandOptions["remove"]).IfDefined; }
set { SetCommandOption("remove", "-d", value); }
}
///
/// Indicates whether the tag specified in should
/// be moved to the current file revision. If the tag does not exist
/// then it is created.
///
///
/// if the specified tag should be moved;
/// otherwise, . The default is .
///
[TaskAttribute("move-if-exists", Required=false)]
[BooleanValidator()]
public bool MoveIfExists {
get { return ((Option)CommandOptions["move-if-exists"]).IfDefined; }
set { SetCommandOption("move-if-exists", "-F", value); }
}
///
/// If a directory is specified indicates whether sub-directories should
/// also be processed.
///
///
/// if the sub-directories should be tagged;
/// otherwise, . The default is .
///
[TaskAttribute("recursive", Required=false)]
[BooleanValidator()]
public bool Recursive {
get { return ((Option)CommandOptions["recursive"]).IfDefined; }
set {
SetCommandOption("recursive", "-R", value);
SetCommandOption("local-only", "-l", !value);
}
}
///
/// Indicates the repository that is acted on
/// for the tag command. Note if is
/// then the tag specified is moved to the revision
/// of the file on the HEAD of the branch specified.
///
///
/// The tag (or more likely) branch that should be used to apply the new tag.
///
[TaskAttribute("act-on-tag", Required=false)]
[StringValidator(AllowEmpty=false, Expression=@"^[A-Za-z0-9][A-Za-z0-9._\-]*$")]
public string ActOnTag {
get { return ((Option)CommandOptions["act-on-tag"]).Value; }
set { SetCommandOption("act-on-tag", String.Format(CultureInfo.InvariantCulture,"-r {0}", value), true); }
}
///
/// Indicates the revision date of the file that the tag should be
/// applied to.
///
///
/// A valid date which specifies the revision point that the tag will
/// be applied to.
///
[TaskAttribute("act-on-date", Required=false)]
[DateTimeValidator()]
public DateTime ActOnDate {
get { return Convert.ToDateTime(((Option)CommandOptions["act-on-date"]).Value); }
set { SetCommandOption("act-on-date", String.Format(CultureInfo.InvariantCulture,"-D {0}", ToCvsDateTimeString(value)), true); }
}
///
/// Indicates whether the head revision should be used if the revision specified by
/// or the tags are not
/// found.
///
///
/// if the specified tag should be moved;
/// otherwise, . The default is .
///
[TaskAttribute("force-head", Required=false)]
[BooleanValidator()]
public bool ForceHead {
get { return ((Option)CommandOptions["force-head"]).IfDefined; }
set { SetCommandOption("force-head", "-f", value); }
}
///
/// Indicates whether the head revision should be used if the
/// or the tags are not
/// found.
///
///
/// if the specified tag should be moved;
/// otherwise, . The default is .
///
[TaskAttribute("fail-if-modified", Required=false)]
[BooleanValidator()]
public bool FailIfModified {
get { return ((Option)CommandOptions["fail-if-modified"]).IfDefined; }
set { SetCommandOption("fail-if-modified", "-c", value); }
}
#endregion Public Instance Properties
#region Override implementation of AbstractCvsTask
///
/// The name of the cvs command that is going to be executed.
///
public override string CommandName {
get { return CvsCommandName; }
}
///
/// Not used
///
public override string Module {
get { return null; }
set { /* module not used for cvs-tag */ }
}
///
/// Append the tag information to the commandline.
///
protected override void AppendSubCommandArgs() {
base.AppendSubCommandArgs ();
if (this.Tag != null && this.Tag != string.Empty) {
this.AddArg(this.Tag);
}
}
///
/// Specify if the module is needed for this cvs command. It is
/// only needed if there is no module information on the local file
/// system.
///
protected override bool IsModuleNeeded {
get { return false; }
}
#endregion Override implementation of AbstractCvsTask
}
}
nant-0.92-rc1/src/NAnt.SourceControl/Tasks/UpdateTask.cs 0000644 0001750 0001750 00000017636 11757302274 022756 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Clayton Harbour (claytonharbour@sporadicism.com)
using System;
using System.Globalization;
using System.IO;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.Core.Util;
namespace NAnt.SourceControl.Tasks {
///
/// Updates a CVS module in a local working directory.
///
///
/// Update nant.
///
///
/// ]]>
///
///
///
///
/// Update your NAnt revision named your_favorite_revision_here in
/// the folder c:\src\nant\replacement_for_module_directory_name.
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("cvs-update")]
public class UpdateTask : AbstractCvsTask {
#region Internal Static Fields
///
/// The command being executed.
///
internal const string CvsCommandName = "update";
#endregion Internal Static Fields
#region Public Instance Constructors
///
/// Initializes a new instance of the
/// class.
///
///
/// Sets the build directory and prune empty directory properties to
/// .
///
public UpdateTask() {
BuildDirs = true;
PruneEmpty = true;
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// If . new directories will be created on the local
/// sandbox. The default is .
///
[TaskAttribute("builddirs", Required=false)]
[BooleanValidator()]
public bool BuildDirs {
get { return ((Option)CommandOptions["builddirs"]).IfDefined; }
set { SetCommandOption("builddirs", "-d", value); }
}
///
/// If empty directories copied down from the
/// remote repository will be removed from the local sandbox.
/// The default is .
///
[TaskAttribute("pruneempty", Required=false)]
[BooleanValidator()]
public bool PruneEmpty {
get { return ((Option)CommandOptions["pruneempty"]).IfDefined; }
set { SetCommandOption("pruneempty", "-P", value); }
}
///
/// If the local copy of the file will be
/// overwritten with the copy from the remote repository. The default
/// is .
///
[TaskAttribute("overwritelocal", Required=false)]
[BooleanValidator()]
public bool OverwriteLocal {
get { return ((Option)CommandOptions["overwritelocal"]).IfDefined; }
set { SetCommandOption("overwritelocal", "-C", value); }
}
///
/// Specifies if the command should be executed recursively. The
/// default is .
///
///
/// The -R option is on by default in cvs.
///
[TaskAttribute("recursive", Required=false)]
[BooleanValidator()]
public bool Recursive {
get {
Option option = (Option) CommandOptions["recursive"];
if (option == null || option.Value == "-R") {
return true;
}
return false;
}
set {
if (value) {
// update should be executed recursive
SetCommandOption("recursive", "-R", true);
} else {
// update should be executed locally (not recursive)
SetCommandOption("recursive", "-l", true);
}
}
}
///
/// Specify the revision to update the file to. This corresponds to the
/// "sticky-tag" of the file.
///
[TaskAttribute("revision", Required=false)]
[StringValidator(AllowEmpty=true, Expression=@"^[A-Za-z0-9][A-Za-z0-9._\-]*$")]
public string Revision {
get {
if (CommandOptions.ContainsKey("revision")) {
return ((Option)CommandOptions["revision"]).Value;
}
return null;
}
set {
if (String.IsNullOrEmpty(value)) {
CommandOptions.Remove("revision");
} else {
SetCommandOption("revision", string.Format(CultureInfo.InvariantCulture,
"-r {0}", value), true);
}
}
}
///
/// Sticky tag or revision to update the local file to.
///
///
/// A valid cvs tag.
///
[TaskAttribute("sticky-tag", Required=false)]
public string StickyTag {
get { return Revision; }
set { Revision = value; }
}
///
/// Specify the revision date to update to. The version of the file that
/// existed at the date specified is retrieved.
///
///
/// A valid date time value, which is then converted to a format that
/// cvs can parse.
///
[TaskAttribute("date", Required=false)]
[DateTimeValidator()]
public DateTime Date {
get { return Convert.ToDateTime(((Option)CommandOptions["date"]).Value); }
set { SetCommandOption("date", String.Format(CultureInfo.InvariantCulture,"-D \"{0}\"", ToCvsDateTimeString(value)), true); }
}
#endregion
#region Override implementation of AbstractCvsTask
///
/// Specify if the module is needed for this cvs command. It is
/// only needed if there is no module information on the local file
/// system.
///
protected override bool IsModuleNeeded {
get {return false;}
}
///
/// The name of the cvs command that is going to be executed.
///
public override string CommandName {
get {return CvsCommandName;}
}
#endregion Override implementation of AbstractCvsTask
}
}
nant-0.92-rc1/src/NAnt.SourceControl/Tasks/AbstractCvsTask.cs 0000644 0001750 0001750 00000053136 11757302274 023746 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Clayton Harbour (claytonharbour@sporadicism.com)
using System;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Globalization;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.SourceControl.Types;
using ICSharpCode.SharpCvsLib.FileSystem;
namespace NAnt.SourceControl.Tasks {
///
/// A base class for creating tasks for executing CVS client commands on a
/// CVS repository.
///
public abstract class AbstractCvsTask : AbstractSourceControlTask {
#region Private Static Fields
private static readonly log4net.ILog Logger = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
#endregion Private Static Fields
#region Protected Static Fields
///
/// Default value for the recursive directive. The default is
/// .
///
protected const bool DefaultRecursive = false;
///
/// Default value for the quiet command.
///
protected const bool DefaultQuiet = false;
///
/// Default value for the really quiet command.
///
protected const bool DefaultReallyQuiet = false;
///
/// An environment variable that holds path information about where
/// cvs is located.
///
protected const string CvsHome = "CVS_HOME";
///
/// Name of the password file that cvs stores pserver
/// cvsroot/ password pairings.
///
protected const String CvsPassfile = ".cvspass";
///
/// The default compression level to use for cvs commands.
///
protected const int DefaultCompressionLevel = 3;
///
/// The default use of binaries, defaults to use sharpcvs.
///
protected const bool DefaultUseSharpCvsLib = true;
///
/// The name of the cvs executable.
///
protected const string CvsExe = "cvs.exe";
///
/// The temporary name of the sharpcvslib binary file, to avoid
/// conflicts in the path variable.
///
protected const string SharpCvsExe = "scvs.exe";
///
/// Environment variable that holds the executable name that is used for
/// ssh communication.
///
protected const string CvsRsh = "CVS_RSH";
///
/// Property name used to specify on a project level whether sharpcvs is
/// used or not.
///
protected const string UseSharpCvsLibProp = "sourcecontrol.usesharpcvslib";
#endregion "Protected Static Fields
#region Private Instance Fields
private string _module;
private bool _useSharpCvsLib = DefaultUseSharpCvsLib;
private bool _isUseSharpCvsLibSet = false;
private FileInfo _cvsFullPath;
private string _sharpcvslibExeName;
private CvsFileSet _cvsFileSet = new CvsFileSet();
#endregion Private Instance Fields
#region Protected Instance Contructors
///
/// Initializes a new instance of the
/// class.
///
protected AbstractCvsTask () : base() {
_sharpcvslibExeName =
Path.Combine (System.AppDomain.CurrentDomain.BaseDirectory, SharpCvsExe);
}
#endregion Protected Instance Constructors
#region Protected Instance Properties
///
/// The environment name for the ssh variable.
///
protected override string SshEnv {
get { return CvsRsh; }
}
///
/// The name of the cvs binary, or cvs.exe at the time this
/// was written.
///
protected override string VcsExeName {
get { return CvsExe; }
}
///
/// The name of the pass file, or .cvspass at the time
/// of this writing.
///
protected override string PassFileName {
get { return CvsPassfile; }
}
///
/// The name of the version control system specific home environment
/// variable.
///
protected override string VcsHomeEnv {
get { return CvsHome; }
}
///
/// Specify if the module is needed for this cvs command. It is
/// only needed if there is no module information on the local file
/// system.
///
protected virtual bool IsModuleNeeded {
get { return true; }
}
#endregion
#region Protected Instance Methods
///
/// Converts a date value to a string representation that can be
/// interpreted by cvs.
///
/// Date to convert.
///
/// String interpretation of .
///
protected string ToCvsDateTimeString(DateTime item) {
return string.Format("{0} {1,2} {2}", item.ToString("ddd MMM"),
item.Day.ToString(), item.ToString("HH:mm:ss yyyy"));
}
#endregion Protected Instance Methods
#region Public Instance Properties
///
/// Used to specify the version control system (VCS) files that are going
/// to be acted on.
///
[BuildElement("fileset")]
public CvsFileSet CvsFileSet {
get { return this._cvsFileSet; }
set { this._cvsFileSet = value; }
}
///
/// Get the cvs file set.
///
public override FileSet VcsFileSet{
get { return this.CvsFileSet; }
}
///
/// The name of the cvs executable.
///
public override string ExeName {
get {
if (null != CvsFullPath) {
return CvsFullPath.FullName;
}
string _exeNameTemp;
if (UseSharpCvsLib) {
_exeNameTemp = _sharpcvslibExeName;
} else {
FileInfo vcsFile = DeriveVcsFromEnvironment();
if (vcsFile == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"'{0}' could not be found on the system.", VcsExeName),
Location);
}
_exeNameTemp = vcsFile.FullName;
}
Logger.Debug("_sharpcvslibExeName: " + _sharpcvslibExeName);
Logger.Debug("_exeNameTemp: " + _exeNameTemp);
Properties[PropExeName] = _exeNameTemp;
return _exeNameTemp;
}
}
///
/// The full path to the cvs binary used. The cvs tasks will attempt to
/// "guess" the location of your cvs binary based on your path. If the
/// task is unable to resolve the location, or resolves it incorrectly
/// this can be used to manually specify the path.
///
///
/// A full path (i.e. including file name) of your cvs binary:
/// On Windows: c:\vcs\cvs\cvs.exe
/// On *nix: /usr/bin/cvs
///
[TaskAttribute("cvsfullpath", Required=false)]
public FileInfo CvsFullPath {
get { return _cvsFullPath; }
set { _cvsFullPath = value; }
}
///
///
/// The cvs root variable has the following components:
///
///
/// [protocol]:[username]@[servername]:[server path]
///
///
protocol: ext, pserver, ssh (sharpcvslib); if you are not using sharpcvslib consult your cvs documentation.
///
username: [username]
///
servername: cvs.sourceforge.net
///
server path: /cvsroot/nant
///
///
///
///
/// NAnt anonymous cvsroot:
///
/// :pserver:anonymous@cvs.sourceforge.net:/cvsroot/nant
///
///
[TaskAttribute("cvsroot", Required=false)]
[StringValidator(AllowEmpty=false)]
public override string Root {
get {
if (null == base.Root) {
try {
ICSharpCode.SharpCvsLib.FileSystem.Root root =
ICSharpCode.SharpCvsLib.FileSystem.Root.Load(this.DestinationDirectory);
this.Root = root.FileContents;
} catch (ICSharpCode.SharpCvsLib.Exceptions.CvsFileNotFoundException) {
throw new BuildException (string.Format("Cvs/Root file not found in {0}, please perform a checkout.",
this.DestinationDirectory.FullName));
}
}
return base.Root;
}
set { base.Root = StringUtils.ConvertEmptyToNull(value); }
}
///
/// The module to perform an operation on.
///
///
/// The module to perform an operation on. This is a normal file/folder
/// name without path information.
///
///
/// In NAnt the module name would be:
/// nant
///
[TaskAttribute("module", Required=false)]
[StringValidator(AllowEmpty=true)]
public virtual string Module {
get {
if (null == _module) {
try {
Repository repository = Repository.Load(this.DestinationDirectory);
this._module = repository.ModuleName;
} catch (ICSharpCode.SharpCvsLib.Exceptions.CvsFileNotFoundException) {
throw new BuildException (string.Format("Cvs/Repository file not found in {0}, please perform a checkout.",
this.DestinationDirectory.FullName));
}
}
return _module;
}
set { _module = StringUtils.ConvertEmptyToNull(value); }
}
///
///
/// if the SharpCvsLib binaries that come bundled
/// with NAnt should be used to perform the cvs commands,
/// otherwise.
///
///
/// You may also specify an override value for all cvs tasks instead
/// of specifying a value for each. To do this set the property
/// sourcecontrol.usesharpcvslib to .
///
///
/// If you choose not to use SharpCvsLib to checkout from cvs you will
/// need to include a cvs.exe binary in your path.
///
///
///
/// To use a cvs client in your path instead of sharpcvslib specify
/// the property:
/// >property name="sourcecontrol.usesharpcvslib" value="false"<
///
/// The default settings is to use sharpcvslib and the setting closest
/// to the task execution is used to determine which value is used
/// to execute the process.
///
/// For instance if the attribute usesharpcvslib was set to false
/// and the global property was set to true, the usesharpcvslib is
/// closes to the point of execution and would be used and is false.
/// Therefore the sharpcvslib binary would NOT be used.
///
[TaskAttribute("usesharpcvslib", Required=false)]
public virtual bool UseSharpCvsLib {
get { return _useSharpCvsLib; }
set {
_isUseSharpCvsLibSet = true;
_useSharpCvsLib = value;
}
}
///
/// The executable to use for ssh communication.
///
[TaskAttribute("cvsrsh", Required=false)]
public override FileInfo Ssh {
get { return base.Ssh; }
set { base.Ssh = value; }
}
///
/// Indicates if the output from the cvs command should be supressed.
/// The default is .
///
[TaskAttribute("quiet", Required=false)]
[BooleanValidator()]
public bool Quiet {
get {
Option option = (Option)GlobalOptions["quiet"];
return null == option ? false : option.IfDefined;
}
set { SetGlobalOption("quiet", "-q", value); }
}
///
/// Indicates if the output from the cvs command should be stopped.
/// The default is .
///
[TaskAttribute("reallyquiet", Required=false)]
[BooleanValidator()]
public bool ReallyQuiet {
get {
Option option = (Option)GlobalOptions["reallyquiet"];
return null == option ? false : option.IfDefined;
}
set { SetGlobalOption("reallyquiet", "-Q", value); }
}
///
/// if the sandbox files should be checked out in
/// read only mode. The default is .
///
[TaskAttribute("readonly", Required=false)]
[BooleanValidator()]
public bool ReadOnly {
get {
Option option = (Option)GlobalOptions["readonly"];
return null == option ? false : option.IfDefined;
}
set { SetGlobalOption("readonly", "-r", value); }
}
///
/// if the sandbox files should be checked out in
/// read/write mode. The default is .
///
[TaskAttribute("readwrite", Required=false)]
[BooleanValidator()]
public bool ReadWrite {
get {
Option option = (Option)GlobalOptions["readwrite"];
return null == option ? false : option.IfDefined;
}
set { SetGlobalOption("readwrite", "-w", value); }
}
///
/// Compression level to use for all net traffic. This should be a value from 1-9.
///
///
/// NOTE: This is not available on sharpcvslib.
///
[TaskAttribute("compressionlevel")]
public int CompressionLevel {
get {
Option option = (Option)GlobalOptions["compressionlevel"];
return null == option ? DefaultCompressionLevel : Convert.ToInt32(option.Value);
}
set { SetGlobalOption("readwrite", String.Format("-z{0}", value), true); }
}
#endregion Public Instance Properties
#region Override Task Implementation
///
/// Build up the command line arguments, determine which executable is being
/// used and find the path to that executable and set the working
/// directory.
///
/// The process to prepare.
protected override void PrepareProcess (Process process) {
// Although a global property can be set, take the property closest
// to the task execution, which is the attribute on the task itself.
if (!_isUseSharpCvsLibSet &&
(null == Properties || null == Properties[UseSharpCvsLibProp])) {
// if not set and the global property is null then use the default
_useSharpCvsLib = UseSharpCvsLib;
} else if (!_isUseSharpCvsLibSet &&
null != Properties[UseSharpCvsLibProp]){
try {
_useSharpCvsLib =
System.Convert.ToBoolean(Properties[UseSharpCvsLibProp]);
} catch (Exception) {
throw new BuildException (UseSharpCvsLib + " must be convertable to a boolean.");
}
}
Logger.Debug("number of arguments: " + Arguments.Count);
// if set, pass cvsroot to command line tool
if (Root != null) {
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"-d{0}", Root)));
}
if (this.UseSharpCvsLib) {
Managed = ManagedExecution.Auto;
}
// Set verbose logging on the #cvslib client if used.
if (this.UseSharpCvsLib && this.Verbose) {
SetGlobalOption("verbose", String.Format("-verbose"), true);
}
AppendGlobalOptions();
Arguments.Add(new Argument(CommandName));
AppendCommandOptions();
Log(Level.Debug, "Commandline args are null: {0}",
((null == CommandLineArguments) ? "yes" : "no"));
Log(Level.Debug, "Commandline: {0}", CommandLineArguments);
if (null != CommandLineArguments) {
Arguments.Add(new Argument(CommandLineArguments));
}
AppendSubCommandArgs();
AppendFiles();
if (IsModuleNeeded && null == Module) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Cvs module is required for this action."),
Location);
}
if (IsModuleNeeded) {
Arguments.Add(new Argument(Module));
}
if (!Directory.Exists(DestinationDirectory.FullName)) {
Directory.CreateDirectory(DestinationDirectory.FullName);
}
base.PrepareProcess(process);
process.StartInfo.FileName = ExeName;
process.StartInfo.WorkingDirectory = DestinationDirectory.FullName;
Log(Level.Verbose, "Working directory: {0}", process.StartInfo.WorkingDirectory);
Log(Level.Verbose, "Executable: {0}", process.StartInfo.FileName);
Log(Level.Verbose, "Arguments: {0}", process.StartInfo.Arguments);
}
///
/// Override to append any commands before the modele and files.
///
protected virtual void AppendSubCommandArgs() {
}
#endregion
#region Private Instance Methods
private void AppendGlobalOptions () {
foreach (Option option in GlobalOptions.Values) {
// Log(Level.Verbose, "Type '{0}'.", optionte.GetType());
if (!option.IfDefined || option.UnlessDefined) {
// skip option
continue;
}
AddArg(option.Value);
}
}
///
/// Append the command line options or commen names for the options
/// to the generic options collection. This is then piped to the
/// command line as a switch.
///
private void AppendCommandOptions () {
foreach (Option option in CommandOptions.Values) {
if (!option.IfDefined || option.UnlessDefined) {
// skip option
continue;
}
AddArg(option.Value);
}
}
///
/// Add the given argument to the command line options. Note that are not explicitly
/// quoted are split into seperate arguments. This is to resolve a recent issue
/// with quoting command line arguments.
///
///
protected void AddArg (String arg) {
if (arg.IndexOf(" ") > -1 && arg.IndexOf("\"") == -1) {
string[] args = arg.Split(' ');
foreach (string targ in args) {
Arguments.Add(
new Argument(String.Format(CultureInfo.InvariantCulture,"{0}", targ)));
}
} else {
Arguments.Add(new Argument(String.Format(CultureInfo.InvariantCulture,"{0}",
arg)));
}
}
#endregion Private Instance Methods
}
}
nant-0.92-rc1/src/NAnt.SourceControl/NAnt.SourceControl.csproj 0000644 0001750 0001750 00000011666 11757302274 024154 0 ustar jtaylor jtaylor
DebugAnyCPU2.0{6B2EC648-8D69-4096-B4F9-6EDC0B2F98EF}NAnt.SourceControlNAnt.SourceControlTasksLibraryOnSuccessfulBuildfalse8.0.50727v2.02.0publish\trueDiskfalseForeground7Daysfalsefalsetrue01.0.0.%2afalsefalsetruetruefullfalse4..\..\build\Debug\AllRules.rulesetTRACE;DEBUG..\..\build\Debug\NAnt.SourceControlTasks.xmltruepdbonlytrue..\..\build\Release\4AllRules.rulesetTRACE..\..\build\Release\NAnt.SourceControlTasks.xml..\..\lib\common\neutral\log4net.dll..\..\lib\common\neutral\ICSharpCode.SharpCvsLib.dll..\..\lib\common\neutral\ICSharpCode.SharpZipLib.dll
CommonAssemblyInfo.cs
False.NET Framework 3.5 SP1 Client ProfilefalseFalse.NET Framework 3.5 SP1trueFalseWindows Installer 3.1true{8F5F8375-4097-4952-B860-784EB9961ABE}NAnt.Core nant-0.92-rc1/src/NAnt.NUnit/ 0000755 0001750 0001750 00000000000 11757310030 015501 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.NUnit/NAnt.NUnit.build 0000644 0001750 0001750 00000006650 11757302274 020440 0 ustar jtaylor jtaylor
nant-0.92-rc1/src/NAnt.NUnit/NUnit1/ 0000755 0001750 0001750 00000000000 11757310030 016617 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.NUnit/NUnit1/XmlResultFormatter.cs 0000644 0001750 0001750 00000014647 11757302274 023020 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
// Ian MacLean (ian_maclean@another.com)
// Gerry Shaw (gerry_shaw@yahoo.com)
using System;
using System.Globalization;
using System.IO;
using System.Text;
using System.Xml;
using NUnit.Framework;
using NAnt.Core.Util;
namespace NAnt.NUnit1.Types {
///
/// Prints detailed information about running tests in XML format.
///
public class XmlResultFormatter : IResultFormatter {
#region Public Instance Constructors
///
/// Initializes a new instance of the
/// class.
///
public XmlResultFormatter() {
_document = new XmlDocument();
}
#endregion Public Instance Constructors
#region Public Instance Properties
public TextWriter Writer {
get { return _writer; }
set { _writer = value; }
}
#endregion Public Instance Properties
#region Implemenation of IResultFormatter
///
/// Sets the the formatter is supposed to
/// write its results to.
///
public void SetOutput(TextWriter writer) {
Writer = writer;
}
///
/// Called when the whole test suite has started.
///
public void StartTestSuite(NUnitTestData suite) {
XmlDeclaration decl = _document.CreateXmlDeclaration("1.0", null, null);
_document.AppendChild(decl);
_suiteElement = _document.CreateElement(ElementTestSuite);
//
// if this is a testsuite, use it's name
//
string suiteName = suite.Suite.ToString();
if (String.IsNullOrEmpty(suiteName)) {
suiteName = "test";
}
_suiteElement.SetAttribute(AttributeName, suiteName );
}
///
/// Called when the whole test suite has ended.
///
public void EndTestSuite(TestResultExtra result) {
_suiteElement.SetAttribute(AttributeTests , result.RunCount.ToString(NumberFormatInfo.InvariantInfo));
double time = result.RunTime;
time /= 1000D;
_suiteElement.SetAttribute(AttributeTime, time.ToString("#####0.000", NumberFormatInfo.InvariantInfo));
_document.AppendChild(_suiteElement);
_suiteElement.SetAttribute(AttributeErrors , result.ErrorCount.ToString(NumberFormatInfo.InvariantInfo));
_suiteElement.SetAttribute(AttributeFailures , result.FailureCount.ToString(NumberFormatInfo.InvariantInfo));
// Send all output to here
_document.Save(Writer);
Writer.Flush();
Writer.Close();
}
#endregion Implemenation of IResultFormatter
#region Implemenation of ITestListener
public void AddError(ITest test, Exception t) {
FormatError(ElementError, test, t);
}
public void AddFailure(ITest test, AssertionFailedError t) {
FormatError(ElementFailure, test, (Exception)t);
}
public void StartTest(ITest test) {
_testStartTime = DateTime.Now;
_currentTest = _document.CreateElement(ElementTestCase);
_currentTest.SetAttribute(AttributeName, ((TestCase ) test).ToString());
string className = test.GetType().FullName;
_currentTest.SetAttribute(AttributeClassname, className);
_suiteElement.AppendChild(_currentTest);
}
public void EndTest(ITest test) {
TimeSpan elapsedTime = DateTime.Now - _testStartTime;
double time = elapsedTime.Milliseconds;
time /= 1000D;
_currentTest.SetAttribute(AttributeTime, time.ToString("#####0.000", NumberFormatInfo.InvariantInfo));
}
#endregion Implemenation of ITestListener
#region Private Instance Methods
private void FormatError(string type, ITest test, Exception t) {
if (test != null) {
EndTest(test);
}
XmlElement nested = _document.CreateElement(type);
if (test != null) {
_currentTest.AppendChild(nested);
} else {
_suiteElement.AppendChild(nested);
}
string message = t.Message;
if (message != null && message.Length > 0) {
nested.SetAttribute( AttributeMessage, message );
}
nested.SetAttribute(AttributeType, t.GetType().FullName);
XmlText traceElement = _document.CreateTextNode(t.StackTrace);
nested.AppendChild(traceElement);
}
#endregion Private Instance Methods
#region Private Instance Fields
TextWriter _writer;
XmlDocument _document;
XmlElement _suiteElement;
XmlElement _currentTest;
DateTime _testStartTime;
#endregion Private Instance Fields
#region Private Static Fields
const string ElementTestSuite = "testsuite";
const string ElementTestCase = "testcase";
const string ElementError = "error";
const string ElementFailure = "failure";
const string AttributeName = "name";
const string AttributeTime = "time";
const string AttributeErrors = "errors";
const string AttributeFailures = "failures";
const string AttributeTests = "tests";
const string AttributeType = "type";
const string AttributeMessage = "message";
const string AttributeClassname = "classname";
#endregion Private Static Fields
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit1/AssemblyInfo.cs 0000644 0001750 0001750 00000002332 11757302274 021554 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Scott Hernandez (ScottHernandez@hotmail.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System.Reflection;
// This will not compile with Visual Studio. If you want to build a signed
// executable use the NAnt build file. To build under Visual Studio just
// exclude this file from the build.
[assembly: AssemblyDelaySign(false)]
//[assembly: AssemblyKeyFile(@"..\NAnt.key")]
[assembly: AssemblyKeyName("")] nant-0.92-rc1/src/NAnt.NUnit/NUnit1/TestResultExtra.cs 0000644 0001750 0001750 00000003454 11757302274 022311 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Ian MacLean (ian_maclean@another.com)
using NUnit.Framework;
namespace NAnt.NUnit1.Types {
///
/// Decorates NUnits with extra information such as
/// run-time.
///
public class TestResultExtra : TestResult {
#region Public Instance Constructors
///
/// Initializes a new instance of the
/// class.
///
public TestResultExtra() {
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets or sets the total run-time of a test.
///
/// The total run-time of a test.
public long RunTime {
get { return _runTime; }
set { _runTime = value; }
}
#endregion Public Instance Properties
#region Private Instance Fields
private long _runTime;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit1/PlainTextFormatter.cs 0000644 0001750 0001750 00000010701 11757302274 022754 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
using System;
using System.IO;
using System.Text.RegularExpressions;
using NUnit.Framework;
namespace NAnt.NUnit1.Types {
///
/// Prints information about running tests in plain text.
///
public class PlainTextFormatter : IResultFormatter {
#region Public Instance Constructors
public PlainTextFormatter() {
}
#endregion Public Instance Constructors
#region Public Instance Properties
public TextWriter Writer {
get { return _writer; }
set { _writer = value; }
}
#endregion Public Instance Properties
#region Implementation of IResultFormatter
/// Sets the Writer the formatter is supposed to write its results to.
public void SetOutput(TextWriter writer) {
Writer = writer;
}
/// Called when the whole test suite has started.
public void StartTestSuite(NUnitTestData suite) {
}
/// Called when the whole test suite has ended.
public void EndTestSuite(TestResultExtra result) {
Writer.WriteLine("------------------------------------------");
if (result.WasSuccessful) {
Writer.WriteLine("{0} tests: ALL SUCCESSFUL", result.RunCount);
} else {
Writer.WriteLine("{0} tests: FAILURES: {1} ERRORS: {2}",
result.RunCount, result.FailureCount, result.ErrorCount);
}
Writer.Flush();
Writer.Close();
}
#endregion Implementation of IResultFormatter
#region Implementation of ITestListener
public void AddError(ITest test, Exception e) {
Writer.WriteLine("ERROR: " + test.ToString());
Writer.WriteLine(FormatError(e.StackTrace, e.Message));
}
public void AddFailure(ITest test, AssertionFailedError e) {
Writer.WriteLine("FAILURE: " + test.ToString());
Writer.WriteLine(FormatError(e.StackTrace, e.Message));
}
public void StartTest(ITest test) {
// TODO: the output from ToString is hard to read, change this to output ClassName.TestName
Writer.WriteLine(test.ToString());
}
public void EndTest(ITest test) {
}
#endregion Implementation of ITestListener
#region Private Static Methods
/// Convert a stack trace line into something that can be clicked on in an IDE output window.
/// The StackTrace string, see .
/// The string that gets appended to the end of file(line): portion.
private static string FormatError(string trace, string message) {
// if we can't find a filename(line#) string, then at least display the message
string line = message;
string[] lines = trace.Split(new char[] {'\n'});
// search the stack trace for the first filename(linenumber) like string
Regex r = new Regex(@"^\s+at (?.+) in (?.+):line (?\d+)$");
foreach (string str in lines) {
Match match = r.Match(str);
if (match.Success) {
line = match.Result("${file}(${line}): ") + message;
break; // no need to continue
}
}
return line;
}
#endregion Private Static Methods
#region Private Instance Fields
TextWriter _writer = null;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit1/IResultFormatter.cs 0000644 0001750 0001750 00000002703 11757302274 022436 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Ian MacLean (ian_maclean@another.com)
// Gerry Shaw (gerry_shaw@yahoo.com)
using System.IO;
using NUnit.Framework;
namespace NAnt.NUnit1.Types {
public interface IResultFormatter : ITestListener {
///
/// The whole test suite started.
///
void StartTestSuite(NUnitTestData suite);
///
/// The whole test suite ended.
///
void EndTestSuite(TestResultExtra result);
///
/// Sets the the formatter is supposed to write
/// its results to.
///
void SetOutput(TextWriter writer);
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit1/NUnitTask.cs 0000644 0001750 0001750 00000022220 11757302274 021037 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Ian MacLean (ian_maclean@another.com)
// Gerry Shaw (gerry_shaw@yahoo.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Globalization;
using System.Runtime.Remoting;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.NUnit.Types;
using NAnt.NUnit1.Types;
using System.Security;
using System.Security.Permissions;
using System.Security.Policy;
namespace NAnt.NUnit1.Tasks {
///
/// Runs tests using the NUnit V1.0 framework.
///
///
///
/// See the NUnit home page for more
/// information.
///
///
/// The or
/// attributes are only used to stop more than one test suite to stop
/// running. If any test suite fails a build error will be thrown.
/// Set to to
/// ignore test errors and continue build.
///
///
///
///
/// Run tests in the MyProject.Tests.dll assembly.
///
///
/// The test results are logged in results.xml and results.txt
/// using the and
/// formatters, respectively.
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("nunit")]
[Obsolete("In a future release, this task will be moved to NAntContrib. However, we strongly advise you to upgrade to NUnit 2.x.")]
public class NUnitTask : Task {
#region Private Instance Fields
private bool _haltOnError = false;
private bool _haltOnFailure = false;
private int _timeout = 0;
private bool _failuresPresent = false;
private bool _errorsPresent = false;
private NUnitTestCollection _tests = new NUnitTestCollection();
private FormatterElementCollection _formatterElements = new FormatterElementCollection();
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Stops running tests when a test causes an error. The default is
/// .
///
///
/// Implies haltonfailure.
///
[TaskAttribute("haltonerror")]
[BooleanValidator()]
public bool HaltOnError {
get { return _haltOnError; }
set { _haltOnError = value; }
}
///
/// Stops running tests if a test fails (errors are considered failures
/// as well). The default is .
///
[TaskAttribute("haltonfailure")]
[BooleanValidator()]
public bool HaltOnFailure {
get { return _haltOnFailure; }
set { _haltOnFailure = value; }
}
///
/// Cancel the individual tests if they do not finish in the specified
/// time (measured in milliseconds). Ignored if fork is disabled.
///
[TaskAttribute("timeout")]
public int Timeout {
get { return _timeout; }
set { _timeout = value; }
}
///
/// Tests to run.
///
[BuildElementArray("test")]
public NUnitTestCollection Tests {
get { return _tests; }
}
///
/// Formatters to output results of unit tests.
///
[BuildElementArray("formatter")]
public FormatterElementCollection FormatterElements {
get { return _formatterElements; }
}
#endregion Public Instance Properties
#region Override implementation of Task
protected override void ExecuteTask() {
foreach (NUnitTest test in _tests) {
ExecuteTest(test);
}
if (_failuresPresent) {
throw new BuildException("Unit test failed, see build log.", Location);
}
if (_errorsPresent) {
throw new BuildException("Unit test had errors, see build log.", Location);
}
}
#endregion Override implementation of Task
#region Private Instance Methods
private void ExecuteTest(NUnitTest test) {
// Set Defaults
RunnerResult result = RunnerResult.Success;
if (test.ToDir == null) {
test.ToDir = Project.BaseDirectory;
}
if (test.OutFile == null) {
test.OutFile = "TEST-" + test.Class;
}
NUnitTestData testData = test.GetTestData();
foreach (FormatterElement element in FormatterElements) {
testData.Formatters.Add(element.Data);
}
if (testData.Fork == true) {
result = ExecuteInAppDomain(testData);
} else {
result = ExecuteInProc(testData);
}
// Handle return code:
// If there is an error/failure and that it should halt, stop
// everything otherwise just log a statement.
bool errorOccurred = (result == RunnerResult.Errors);
bool failureOccurred = (result != RunnerResult.Success);
if ((errorOccurred && test.HaltOnError) || (failureOccurred && test.HaltOnFailure)) {
// Only thrown if this test should halt as soon as the first
// error/failure is detected. In most cases all tests will
// be run to get a full list of problems.
throw new BuildException("Test " + testData.Class + " Failed" , Location);
}
// Used for reporting the final result from the task.
if (errorOccurred) {
_errorsPresent = true;
}
if (failureOccurred) {
_failuresPresent = true;
}
}
// TODO implement launching in a seperate App Domain
private RunnerResult ExecuteInAppDomain(NUnitTestData test) {
// spawn new domain in specified directory
AppDomainSetup domSetup = new AppDomainSetup();
domSetup.ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
domSetup.ConfigurationFile = Project.GetFullPath(test.AppConfigFile);
domSetup.ApplicationName = "NAnt Remote Domain";
PermissionSet domainPermSet = new PermissionSet(PermissionState.Unrestricted);
AppDomain newDomain = AppDomain.CreateDomain(domSetup.ApplicationName, AppDomain.CurrentDomain.Evidence,
domSetup, domainPermSet);
// instantiate subclassed test runner in new domain
Type runnerType = typeof(RemoteNUnitTestRunner);
ObjectHandle oh = newDomain.CreateInstance (
runnerType.Assembly.FullName,
runnerType.FullName,
false, 0, null,
new object[] { test },
null, null, null
);
RemoteNUnitTestRunner runner = (RemoteNUnitTestRunner)(oh.Unwrap());
Log(Level.Info, "Running '{0}'.", test.Class);
runner.Run(string.Empty, Verbose);
return runner.ResultCode;
}
private RunnerResult ExecuteInProc(NUnitTestData test) {
try {
NUnitTestRunner runner = new NUnitTestRunner(test);
if (runner.NeedsRunning()) {
Log(Level.Info, "Running '{0}'.", test.Class);
runner.Run(string.Empty, Verbose);
} else {
Log(Level.Info, "Skipping '{0}' because tests haven't changed.", test.Class);
}
return runner.ResultCode;
} catch (Exception ex) {
throw new BuildException("Error running unit test.", Location, ex);
}
}
#endregion Private Instance Methods
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit1/LogFormatter.cs 0000644 0001750 0001750 00000012762 11757302274 021576 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
//
// TO-DO : replace Console.WriteLine methods with logging method calls
using System;
using System.IO;
using System.Text.RegularExpressions;
using NUnit.Framework;
namespace NAnt.NUnit1.Types {
///
/// Prints information about running tests directly to the build log.
///
public class LogFormatter : IResultFormatter {
#region Public Instance Constructors
public LogFormatter(string prefix, bool verbose) {
if (prefix != null) {
_prefix = prefix;
} else {
_prefix = String.Empty;
}
_verbose = verbose;
}
#endregion Public Instance Constructors
#region Protected Instance Properties
protected bool Verbose {
get { return _verbose; }
}
protected string Prefix {
get { return _prefix; }
}
#endregion Protected Instance Properties
#region Implementation of IResultFormatter
/// Not used, all output goes to Log class.
public void SetOutput(TextWriter writer) {
}
/// Called when the whole test suite has started.
public void StartTestSuite(NUnitTestData suite) {
if (Verbose) {
Console.WriteLine(Prefix + "------------------------------------------");
}
}
/// Called when the whole test suite has ended.
public void EndTestSuite(TestResultExtra result) {
if (Verbose) {
Console.WriteLine(Prefix + "------------------------------------------");
}
if (result.WasSuccessful) {
Console.WriteLine(Prefix + "{0} tests: ALL SUCCESSFUL", result.RunCount);
} else {
Console.WriteLine(Prefix + "{0} tests: FAILURES: {1} ERRORS: {2}", result.RunCount, result.FailureCount, result.ErrorCount);
}
}
#endregion Implementation of IResultFormatter
#region Implementation of ITestListener
public void AddError(ITest test, Exception e) {
Console.WriteLine(Prefix + "ERROR: " + GetTestSummary(test));
Console.WriteLine(FormatError(e.StackTrace, e.Message));
if (Verbose) {
Console.WriteLine(e.StackTrace);
}
}
public void AddFailure(ITest test, AssertionFailedError e) {
Console.WriteLine(Prefix + "FAILURE: " + GetTestSummary(test));
Console.WriteLine(FormatError(e.StackTrace, e.Message));
if (Verbose) {
Console.WriteLine(e.StackTrace);
}
}
public void StartTest(ITest test) {
if (Verbose) {
Console.WriteLine(Prefix + GetTestSummary(test));
}
}
public void EndTest(ITest test) {
}
#endregion Implementation of ITestListener
#region Private Static Methods
// NOTE: When test.ToString() displays something less stupid than
// MethodName(Namespace.ClassName) think about changing to that. As it
// is now its impossible to sort the test output.
// The workaround is to use this method.
private static string GetTestSummary(ITest test) {
string nunitInfo = test.ToString();
return test.GetType().Name + "." + nunitInfo.Substring(0, nunitInfo.IndexOf('('));
}
/// Convert a stack trace line into something that can be clicked on in an IDE output window.
/// The StackTrace string, see .
/// The string that gets appended to the end of file(line): portion.
private static string FormatError(string trace, string message) {
// if we can't find a filename(line#) string, then at least display the message
string line = message;
string[] lines = trace.Split(new char[] {'\n'});
// search the stack trace for the first filename(linenumber) like string
Regex r = new Regex(@"^\s+at (?.+) in (?.+):line (?\d+)$");
foreach (string str in lines) {
Match match = r.Match(str);
if (match.Success) {
line = match.Result("${file}(${line}): ") + message;
break; // no need to continue
}
}
return line;
}
#endregion Private Static Methods
#region Private Instance Fields
private string _prefix;
private bool _verbose;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit1/NUnitTestCollection.cs 0000644 0001750 0001750 00000021471 11757302274 023077 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
namespace NAnt.NUnit1.Types {
///
/// Contains a strongly typed collection of objects.
///
[Serializable]
public class NUnitTestCollection : CollectionBase {
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public NUnitTestCollection() {
}
///
/// Initializes a new instance of the class
/// with the specified instance.
///
public NUnitTestCollection(NUnitTestCollection value) {
AddRange(value);
}
///
/// Initializes a new instance of the class
/// with the specified array of instances.
///
public NUnitTestCollection(NUnitTest[] value) {
AddRange(value);
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets or sets the element at the specified index.
///
/// The zero-based index of the element to get or set.
[System.Runtime.CompilerServices.IndexerName("Item")]
public NUnitTest this[int index] {
get {return ((NUnitTest)(base.List[index]));}
set {base.List[index] = value;}
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Adds a to the end of the collection.
///
/// The to be added to the end of the collection.
/// The position into which the new element was inserted.
public int Add(NUnitTest item) {
return base.List.Add(item);
}
///
/// Adds the elements of a array to the end of the collection.
///
/// The array of elements to be added to the end of the collection.
public void AddRange(NUnitTest[] items) {
for (int i = 0; (i < items.Length); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Adds the elements of a to the end of the collection.
///
/// The to be added to the end of the collection.
public void AddRange(NUnitTestCollection items) {
for (int i = 0; (i < items.Count); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Determines whether a is in the collection.
///
/// The to locate in the collection.
///
/// if is found in the
/// collection; otherwise, .
///
public bool Contains(NUnitTest item) {
return base.List.Contains(item);
}
///
/// Copies the entire collection to a compatible one-dimensional array, starting at the specified index of the target array.
///
/// The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.
/// The zero-based index in at which copying begins.
public void CopyTo(NUnitTest[] array, int index) {
base.List.CopyTo(array, index);
}
///
/// Retrieves the index of a specified object in the collection.
///
/// The object for which the index is returned.
///
/// The index of the specified . If the is not currently a member of the collection, it returns -1.
///
public int IndexOf(NUnitTest item) {
return base.List.IndexOf(item);
}
///
/// Inserts a into the collection at the specified index.
///
/// The zero-based index at which should be inserted.
/// The to insert.
public void Insert(int index, NUnitTest item) {
base.List.Insert(index, item);
}
///
/// Returns an enumerator that can iterate through the collection.
///
///
/// A for the entire collection.
///
public new NUnitTestEnumerator GetEnumerator() {
return new NUnitTestEnumerator(this);
}
///
/// Removes a member from the collection.
///
/// The to remove from the collection.
public void Remove(NUnitTest item) {
base.List.Remove(item);
}
#endregion Public Instance Methods
}
///
/// Enumerates the elements of a .
///
public class NUnitTestEnumerator : IEnumerator {
#region Internal Instance Constructors
///
/// Initializes a new instance of the class
/// with the specified .
///
/// The collection that should be enumerated.
internal NUnitTestEnumerator(NUnitTestCollection arguments) {
IEnumerable temp = (IEnumerable) (arguments);
_baseEnumerator = temp.GetEnumerator();
}
#endregion Internal Instance Constructors
#region Implementation of IEnumerator
///
/// Gets the current element in the collection.
///
///
/// The current element in the collection.
///
public NUnitTest Current {
get { return (NUnitTest) _baseEnumerator.Current; }
}
object IEnumerator.Current {
get { return _baseEnumerator.Current; }
}
///
/// Advances the enumerator to the next element of the collection.
///
///
/// if the enumerator was successfully advanced
/// to the next element; if the enumerator has
/// passed the end of the collection.
///
public bool MoveNext() {
return _baseEnumerator.MoveNext();
}
bool IEnumerator.MoveNext() {
return _baseEnumerator.MoveNext();
}
///
/// Sets the enumerator to its initial position, which is before the
/// first element in the collection.
///
public void Reset() {
_baseEnumerator.Reset();
}
void IEnumerator.Reset() {
_baseEnumerator.Reset();
}
#endregion Implementation of IEnumerator
#region Private Instance Fields
private IEnumerator _baseEnumerator;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit1/IResultFormatterCollection.cs 0000644 0001750 0001750 00000022220 11757302274 024446 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
namespace NAnt.NUnit1.Types {
///
/// Contains a strongly typed collection of objects.
///
[Serializable]
public class IResultFormatterCollection : CollectionBase {
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public IResultFormatterCollection() {
}
///
/// Initializes a new instance of the class
/// with the specified instance.
///
public IResultFormatterCollection(IResultFormatterCollection value) {
AddRange(value);
}
///
/// Initializes a new instance of the class
/// with the specified array of instances.
///
public IResultFormatterCollection(IResultFormatter[] value) {
AddRange(value);
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets or sets the element at the specified index.
///
/// The zero-based index of the element to get or set.
[System.Runtime.CompilerServices.IndexerName("Item")]
public IResultFormatter this[int index] {
get {return ((IResultFormatter)(base.List[index]));}
set {base.List[index] = value;}
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Adds a to the end of the collection.
///
/// The to be added to the end of the collection.
/// The position into which the new element was inserted.
public int Add(IResultFormatter item) {
return base.List.Add(item);
}
///
/// Adds the elements of a array to the end of the collection.
///
/// The array of elements to be added to the end of the collection.
public void AddRange(IResultFormatter[] items) {
for (int i = 0; (i < items.Length); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Adds the elements of a to the end of the collection.
///
/// The to be added to the end of the collection.
public void AddRange(IResultFormatterCollection items) {
for (int i = 0; (i < items.Count); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Determines whether a is in the collection.
///
/// The to locate in the collection.
///
/// if is found in the
/// collection; otherwise, .
///
public bool Contains(IResultFormatter item) {
return base.List.Contains(item);
}
///
/// Copies the entire collection to a compatible one-dimensional array, starting at the specified index of the target array.
///
/// The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.
/// The zero-based index in at which copying begins.
public void CopyTo(IResultFormatter[] array, int index) {
base.List.CopyTo(array, index);
}
///
/// Retrieves the index of a specified object in the collection.
///
/// The object for which the index is returned.
///
/// The index of the specified . If the is not currently a member of the collection, it returns -1.
///
public int IndexOf(IResultFormatter item) {
return base.List.IndexOf(item);
}
///
/// Inserts a into the collection at the specified index.
///
/// The zero-based index at which should be inserted.
/// The to insert.
public void Insert(int index, IResultFormatter item) {
base.List.Insert(index, item);
}
///
/// Returns an enumerator that can iterate through the collection.
///
///
/// A for the entire collection.
///
public new IResultFormatterEnumerator GetEnumerator() {
return new IResultFormatterEnumerator(this);
}
///
/// Removes a member from the collection.
///
/// The to remove from the collection.
public void Remove(IResultFormatter item) {
base.List.Remove(item);
}
#endregion Public Instance Methods
}
///
/// Enumerates the elements of a .
///
public class IResultFormatterEnumerator : IEnumerator {
#region Internal Instance Constructors
///
/// Initializes a new instance of the class
/// with the specified .
///
/// The collection that should be enumerated.
internal IResultFormatterEnumerator(IResultFormatterCollection arguments) {
IEnumerable temp = (IEnumerable) (arguments);
_baseEnumerator = temp.GetEnumerator();
}
#endregion Internal Instance Constructors
#region Implementation of IEnumerator
///
/// Gets the current element in the collection.
///
///
/// The current element in the collection.
///
public IResultFormatter Current {
get { return (IResultFormatter) _baseEnumerator.Current; }
}
object IEnumerator.Current {
get { return _baseEnumerator.Current; }
}
///
/// Advances the enumerator to the next element of the collection.
///
///
/// if the enumerator was successfully advanced
/// to the next element; if the enumerator has
/// passed the end of the collection.
///
public bool MoveNext() {
return _baseEnumerator.MoveNext();
}
bool IEnumerator.MoveNext() {
return _baseEnumerator.MoveNext();
}
///
/// Sets the enumerator to its initial position, which is before the
/// first element in the collection.
///
public void Reset() {
_baseEnumerator.Reset();
}
void IEnumerator.Reset() {
_baseEnumerator.Reset();
}
#endregion Implementation of IEnumerator
#region Private Instance Fields
private IEnumerator _baseEnumerator;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit1/RemoteNUnitTestRunner.cs 0000644 0001750 0001750 00000003420 11757302274 023423 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Tomas Restrepo (tomasr@mvps.org)
using System;
using NAnt.NUnit1.Types;
namespace NAnt.NUnit1.Tasks {
public class RemoteNUnitTestRunner : MarshalByRefObject {
#region Public Instance Constructors
public RemoteNUnitTestRunner(NUnitTestData testData) {
_runner = new NUnitTestRunner(testData);
}
#endregion Public Instance Constructors
#region Public Instance Properties
public RunnerResult ResultCode {
get { return _runner.ResultCode; }
}
public IResultFormatterCollection Formatters {
get { return _runner.Formatters; }
}
#endregion Public Instance Properties
#region Public Instance Methods
public void Run(string logPrefix, bool verbose) {
_runner.Run(logPrefix, verbose);
}
#endregion Public Instance Methods
#region Private Instance Fields
private NUnitTestRunner _runner;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit1/NUnitTest.cs 0000644 0001750 0001750 00000011106 11757302274 021055 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Ian MacLean (ian_maclean@another.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.NUnit1.Tasks;
namespace NAnt.NUnit1.Types {
///
/// Represents a test element of an .
///
[ElementName("test")]
public class NUnitTest : Element {
#region Private Instance Fields
private string _class = null;
private string _assembly = null;
private bool _fork = false;
private bool _haltonerror = false;
private bool _haltonfailure = false;
private string _appConfigFile = null;
private string _todir = null;
private string _outfile = null;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Base name of the test result. The full filename is determined by this
/// attribute and the extension of formatter.
///
[TaskAttribute("outfile")]
public string OutFile {
get { return _outfile; }
set { _outfile = value; }
}
///
/// Directory to write the reports to.
///
[TaskAttribute("todir")]
public string ToDir {
get { return _todir; }
set { _todir = value; }
}
///
/// Class name of the test.
///
[TaskAttribute("class", Required=true)]
[StringValidator(AllowEmpty=false)]
public string Class {
get { return _class; }
set { _class = value; }
}
///
/// Assembly to load the test from.
///
[TaskAttribute("assembly", Required=true)]
[StringValidator(AllowEmpty=false)]
public string Assembly {
get { return Project.GetFullPath(_assembly); }
set { _assembly = value; }
}
///
/// Run the tests in a separate .
///
[TaskAttribute("fork")]
[BooleanValidator()]
public bool Fork {
get { return _fork; }
set { _fork = value; }
}
///
/// Stop the build process if an error occurs during the test run.
///
[TaskAttribute("haltonerror")]
[BooleanValidator()]
public bool HaltOnError {
get { return _haltonerror; }
set { _haltonerror = value; }
}
///
/// Stop the build process if a test fails (errors are considered failures
/// as well).
///
[TaskAttribute("haltonfailure")]
[BooleanValidator()]
public bool HaltOnFailure {
get { return _haltonfailure; }
set { _haltonfailure = value; }
}
///
/// The application configuration file to use for the NUnit test domain.
///
[TaskAttribute("appconfig")]
public string AppConfigFile {
get { return _appConfigFile; }
set { _appConfigFile = value; }
}
#endregion Public Instance Properties
#region Internal Instance Methods
internal NUnitTestData GetTestData() {
NUnitTestData data = new NUnitTestData();
data.OutFile = OutFile;
data.ToDir = ToDir;
data.Class = Class;
data.Assembly = Assembly;
data.Fork = Fork;
data.HaltOnError = HaltOnError;
data.HaltOnFailure = HaltOnFailure;
data.AppConfigFile = AppConfigFile;
return data;
}
#endregion Internal Instance Methods
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit1/NUnitTestRunner.cs 0000644 0001750 0001750 00000025163 11757302274 022257 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Ian MacLean (ian_maclean@another.com)
// Gerry Shaw (gerry_shaw@yahoo.com)
using System;
using System.Globalization;
using System.IO;
using System.Xml;
using NUnit.Framework;
using NUnit.Runner;
using NAnt.NUnit.Types;
using NAnt.NUnit1.Types;
namespace NAnt.NUnit1.Tasks {
public enum RunnerResult {
Success,
Failures,
Errors,
}
public class NUnitTestRunner : BaseTestRunner {
#region Public Instance Constructors
public NUnitTestRunner(NUnitTestData testData) {
_nunittest = testData;
string nunitsuite = testData.Class + "," + testData.Assembly;
_suite = GetSuite(nunitsuite);
testData.Suite = _suite;
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets the collection of registered formatters.
///
/// Collection of registered formatters.
public IResultFormatterCollection Formatters {
get { return _formatters; }
}
///
/// Gets the result of the test.
///
/// The result of the test.
public RunnerResult ResultCode {
get { return _resultCode; }
}
#endregion Public Instance Properties
#region Override implementation of BaseTestRunner
protected override void RunFailed(string message) {
}
#endregion Override implementation of BaseTestRunner
#region Override implementation of IListener
public override void AddError(ITest test, Exception t) {
foreach (IResultFormatter formatter in Formatters) {
formatter.AddError(test, t);
}
if (_nunittest.HaltOnError) {
_result.Stop();
}
}
public override void AddFailure(ITest test, AssertionFailedError t) {
foreach (IResultFormatter formatter in Formatters) {
formatter.AddFailure(test, t);
}
if (_nunittest.HaltOnFailure) {
_result.Stop();
}
}
public override void StartTest(ITest test) {
foreach (IResultFormatter formatter in Formatters) {
formatter.StartTest(test);
}
}
public override void EndTest(ITest test) {
foreach (IResultFormatter formatter in Formatters) {
formatter.EndTest(test);
}
}
#endregion Override implementation of IListener
#region Public Instance Methods
///
/// Determines if the unit test needs running.
///
///
/// if unit test needs running, otherwise,
/// .
///
///
///
/// Determines if the test needs running by looking at the date stamp
/// of the test assembly and the test results log.
///
///
public bool NeedsRunning() {
// assume we need to run unless proven otherwise
bool needsRunning = true;
string assemblyFileName = _nunittest.Assembly;
string logFileName = _nunittest.OutFile + ".xml";
if (File.Exists(logFileName) && File.Exists(assemblyFileName)) {
DateTime assemblyDateStamp = File.GetLastWriteTime(assemblyFileName);
DateTime logDataStamp = File.GetLastWriteTime(logFileName);
// simple check of datestamps normally works
if (logDataStamp > assemblyDateStamp) {
// date stamps are ok
// look inside results to see if there were failures or errors
try {
XmlDocument doc = new XmlDocument();
doc.Load(logFileName);
// check for errors or failures
//
int errors = Convert.ToInt32(doc.DocumentElement.Attributes["errors"].Value, NumberFormatInfo.InvariantInfo);
int failuers = Convert.ToInt32(doc.DocumentElement.Attributes["failures"].Value, NumberFormatInfo.InvariantInfo);
if (errors == 0 && failuers == 0) {
// no previous errors or failures and the assembly date stamp is older
// than the log so it should be safe to skip running the tests this time.
needsRunning = false;
}
} catch {
// some sort of error parsing xml, so just run the tests again
}
}
}
return needsRunning;
}
///
/// Runs a Suite extracted from a TestCase subclass.
///
public void Run(string logPrefix, bool verbose) {
CreateFormatters(_nunittest, logPrefix, verbose);
_result = new TestResultExtra();
_result.AddListener(this);
long startTime = System.DateTime.Now.Ticks;
// Handle start
OnStartTestSuite();
_suite.Run(_result);
// finished test
long endTime = System.DateTime.Now.Ticks;
long runTime = (endTime-startTime) / 10000;
_result.RunTime = runTime;
// Handle completion
OnEndTestSuite();
if (_result.WasSuccessful == false) {
if (_result.ErrorCount != 0) {
_resultCode = RunnerResult.Errors;
} else if (_result.FailureCount !=0) {
_resultCode = RunnerResult.Failures;
}
}
}
#endregion Public Instance Methods
#region Protected Instance Methods
///
/// Creates the formatters to be used when running this test.
///
protected void CreateFormatters(NUnitTestData testData, string logPrefix, bool verbose) {
// Now add the specified formatters
foreach (FormatterData formatterData in testData.Formatters) {
// determine file
FileInfo outFile = GetOutput(formatterData, testData);
IResultFormatter formatter = CreateFormatter(formatterData.Type, outFile);
Formatters.Add(formatter);
}
// Add default formatter
// The Log formatter is special in that it always writes to the
// Log class rather than the TextWriter set in SetOutput().
// HACK!
LogFormatter logFormatter = new LogFormatter(logPrefix, verbose);
Formatters.Add(logFormatter);
}
///
/// Returns the output file or null if does not use a file.
///
protected FileInfo GetOutput(FormatterData formatterData, NUnitTestData test) {
if (formatterData.UseFile) {
string filename = test.OutFile + formatterData.Extension;
string absFilename = Path.Combine(test.ToDir, filename);
return new FileInfo(absFilename);
}
return null;
}
protected IResultFormatter CreateFormatter(FormatterType type, FileInfo outfile) {
IResultFormatter retFormatter = null;
switch (type) {
case FormatterType.Plain:
retFormatter = (IResultFormatter) new PlainTextFormatter();
break;
case FormatterType.Xml:
retFormatter = (IResultFormatter) new XmlResultFormatter();
break;
default:
break;
}
if (outfile == null) {
// TO-DO : find solution for creating LogWriter without access to Task or Project
// for dispatching logging events
// retFormatter.SetOutput(new LogWriter());
retFormatter.SetOutput(Console.Out);
} else {
retFormatter.SetOutput(new StreamWriter(outfile.Create()));
}
return retFormatter;
}
#endregion Protected Instance Methods
#region Private Instance Methods
///
/// Returns the test suite from a given class.
///
///
/// The assemblyQualifiedName parameter needs to be in form:
/// "full.qualified.class.name,Assembly"
///
private ITest GetSuite(string assemblyQualifiedName) {
// Don't worry about catching exceptions in this method. The
// NUnitTask will catch them and throw a BuildException back to
// NAnt with the correct location in the build file. [gs]
StandardLoader loader = new StandardLoader();
ITest test = loader.LoadTest(assemblyQualifiedName);
return test;
}
private void OnStartTestSuite() {
foreach (IResultFormatter formatter in Formatters) {
formatter.StartTestSuite(_nunittest);
}
}
private void OnEndTestSuite() {
foreach (IResultFormatter formatter in Formatters) {
formatter.EndTestSuite(_result);
}
}
#endregion Private Instance Methods
#region Private Instance Fields
IResultFormatterCollection _formatters = new IResultFormatterCollection();
NUnitTestData _nunittest = null;
ITest _suite = null;
TestResultExtra _result = null;
RunnerResult _resultCode = RunnerResult.Success;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit1/NAnt.NUnit1.csproj 0000644 0001750 0001750 00000011313 11757302274 022030 0 ustar jtaylor jtaylor
DebugAnyCPU2.0{0F3EA7A9-C5F6-4254-820C-B5E0409B5B9D}NAnt.NUnit1NAnt.NUnit1TasksLibraryOnSuccessfulBuildfalse8.0.50727v2.02.0publish\trueDiskfalseForeground7Daysfalsefalsetrue01.0.0.%2afalsefalsetruetruefullfalse4..\..\build\Debug\AllRules.rulesetTRACE;DEBUG..\..\build\Debug\NAnt.NUnit1Tasks.xmltruepdbonlytrue..\..\build\Release\4AllRules.rulesetTRACE..\..\build\Release\NAnt.NUnit1Tasks.xml..\..\..\lib\common\neutral\NUnitCore.dll
CommonAssemblyInfo.cs
False.NET Framework 3.5 SP1 Client ProfilefalseFalse.NET Framework 3.5 SP1trueFalseWindows Installer 3.1true{8F5F8375-4097-4952-B860-784EB9961ABE}NAnt.Core{00F5C075-9874-4BCE-909A-99C1F600E047}NAnt.NUnit nant-0.92-rc1/src/NAnt.NUnit/NUnit1/NUnitTestData.cs 0000644 0001750 0001750 00000005520 11757302274 021652 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Tomas Restrepo (tomasr@mvps.org)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using NUnit.Framework;
using NAnt.NUnit.Types;
namespace NAnt.NUnit1.Types {
///
/// Carries data specified through the test element.
///
[Serializable]
public class NUnitTestData {
#region Public Instance Properties
public ITest Suite {
get { return _suite; }
set { _suite = value; }
}
public string OutFile {
get { return _outfile; }
set {_outfile = value;}
}
public string ToDir {
get { return _todir; }
set {_todir = value;}
}
public string Class {
get { return _class; }
set { _class = value; }
}
public string Assembly {
get { return _assembly; }
set { _assembly = value; }
}
public bool Fork {
get { return _fork; }
set { _fork = value; }
}
public bool HaltOnError {
get { return _haltonerror; }
set { _haltonerror = value; }
}
public bool HaltOnFailure {
get { return _haltonfailure; }
set { _haltonfailure = value; }
}
public FormatterDataCollection Formatters {
get { return _formatters; }
}
public string AppConfigFile {
get { return _appConfigFile; }
set { _appConfigFile = value; }
}
#endregion Public Instance Properties
#region Private Instance Fields
string _todir = null;
string _outfile = null;
string _class = null;
string _assembly = null;
bool _fork = false;
bool _haltonerror = false;
bool _haltonfailure = false;
ITest _suite = null;
FormatterDataCollection _formatters = new FormatterDataCollection();
string _appConfigFile = null;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.NUnit/NAnt.NUnit.csproj 0000644 0001750 0001750 00000010102 11757302274 020624 0 ustar jtaylor jtaylor
DebugAnyCPU2.0{00F5C075-9874-4BCE-909A-99C1F600E047}NAnt.NUnitNAnt.NUnitLibraryOnSuccessfulBuildfalse8.0.50727v2.02.0publish\trueDiskfalseForeground7Daysfalsefalsetrue01.0.0.%2afalsefalsetruetruefullfalse4..\..\build\Debug\AllRules.rulesetTRACE;DEBUG..\..\build\Debug\NAnt.NUnit.xmltruepdbonlytrue..\..\build\Release\4AllRules.rulesetTRACE..\..\build\Release\NAnt.NUnit.xml
CommonAssemblyInfo.cs
False.NET Framework 3.5 SP1 Client ProfilefalseFalse.NET Framework 3.5 SP1trueFalseWindows Installer 3.1true{8F5F8375-4097-4952-B860-784EB9961ABE}NAnt.Core nant-0.92-rc1/src/NAnt.NUnit/FormatterElement.cs 0000644 0001750 0001750 00000006505 11757302274 021326 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Ian MacLean (ian_maclean@another.com)
using System;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Util;
namespace NAnt.NUnit.Types {
///
/// The built-in formatter types.
///
public enum FormatterType {
///
/// A plaintext formatter.
///
Plain,
///
/// An XML formatter.
///
Xml
}
///
/// Represents the FormatterElement of the NUnit task.
///
[ElementName("formatter")]
public class FormatterElement : NAnt.Core.Element {
#region Private Instance Fields
private FormatterData _data = new FormatterData();
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Type of formatter.
///
[TaskAttribute("type", Required=true)]
public FormatterType Type {
get { return _data.Type; }
set { _data.Type = value; }
}
///
/// Extension to append to the output filename.
///
[TaskAttribute("extension", Required=false)]
public string Extension {
get { return StringUtils.ConvertNullToEmpty(_data.Extension); }
set { _data.Extension = value; }
}
///
/// Determines whether output should be persisted to a file. The default
/// is .
///
[TaskAttribute("usefile", Required=false)]
[BooleanValidator()]
public bool UseFile {
get { return _data.UseFile; }
set { _data.UseFile = value; }
}
///
/// Specifies the directory where the output file should be written to,
/// if is . If not
/// specified, the output file will be written to the directory where
/// the test module is located.
///
[TaskAttribute("outputdir", Required=false)]
public DirectoryInfo OutputDirectory {
get { return _data.OutputDirectory; }
set { _data.OutputDirectory = value; }
}
///
/// Gets the underlying for the element.
///
public FormatterData Data {
get { return _data; }
}
#endregion Public Instance Properties
}
}
nant-0.92-rc1/src/NAnt.NUnit/FormatterElementCollection.cs 0000644 0001750 0001750 00000022217 11757302274 023340 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
namespace NAnt.NUnit.Types {
///
/// Contains a strongly typed collection of objects.
///
[Serializable]
public class FormatterElementCollection : CollectionBase {
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public FormatterElementCollection() {
}
///
/// Initializes a new instance of the class
/// with the specified instance.
///
public FormatterElementCollection(FormatterElementCollection value) {
AddRange(value);
}
///
/// Initializes a new instance of the class
/// with the specified array of instances.
///
public FormatterElementCollection(FormatterElement[] value) {
AddRange(value);
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets or sets the element at the specified index.
///
/// The zero-based index of the element to get or set.
[System.Runtime.CompilerServices.IndexerName("Item")]
public FormatterElement this[int index] {
get {return ((FormatterElement)(base.List[index]));}
set {base.List[index] = value;}
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Adds a to the end of the collection.
///
/// The to be added to the end of the collection.
/// The position into which the new element was inserted.
public int Add(FormatterElement item) {
return base.List.Add(item);
}
///
/// Adds the elements of a array to the end of the collection.
///
/// The array of elements to be added to the end of the collection.
public void AddRange(FormatterElement[] items) {
for (int i = 0; (i < items.Length); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Adds the elements of a to the end of the collection.
///
/// The to be added to the end of the collection.
public void AddRange(FormatterElementCollection items) {
for (int i = 0; (i < items.Count); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Determines whether a is in the collection.
///
/// The to locate in the collection.
///
/// if is found in the
/// collection; otherwise, .
///
public bool Contains(FormatterElement item) {
return base.List.Contains(item);
}
///
/// Copies the entire collection to a compatible one-dimensional array, starting at the specified index of the target array.
///
/// The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.
/// The zero-based index in at which copying begins.
public void CopyTo(FormatterElement[] array, int index) {
base.List.CopyTo(array, index);
}
///
/// Retrieves the index of a specified object in the collection.
///
/// The object for which the index is returned.
///
/// The index of the specified . If the is not currently a member of the collection, it returns -1.
///
public int IndexOf(FormatterElement item) {
return base.List.IndexOf(item);
}
///
/// Inserts a into the collection at the specified index.
///
/// The zero-based index at which should be inserted.
/// The to insert.
public void Insert(int index, FormatterElement item) {
base.List.Insert(index, item);
}
///
/// Returns an enumerator that can iterate through the collection.
///
///
/// A for the entire collection.
///
public new FormatterElementEnumerator GetEnumerator() {
return new FormatterElementEnumerator(this);
}
///
/// Removes a member from the collection.
///
/// The to remove from the collection.
public void Remove(FormatterElement item) {
base.List.Remove(item);
}
#endregion Public Instance Methods
}
///
/// Enumerates the elements of a .
///
public class FormatterElementEnumerator : IEnumerator {
#region Internal Instance Constructors
///
/// Initializes a new instance of the class
/// with the specified .
///
/// The collection that should be enumerated.
internal FormatterElementEnumerator(FormatterElementCollection arguments) {
IEnumerable temp = (IEnumerable) (arguments);
_baseEnumerator = temp.GetEnumerator();
}
#endregion Internal Instance Constructors
#region Implementation of IEnumerator
///
/// Gets the current element in the collection.
///
///
/// The current element in the collection.
///
public FormatterElement Current {
get { return (FormatterElement) _baseEnumerator.Current; }
}
object IEnumerator.Current {
get { return _baseEnumerator.Current; }
}
///
/// Advances the enumerator to the next element of the collection.
///
///
/// if the enumerator was successfully advanced
/// to the next element; if the enumerator has
/// passed the end of the collection.
///
public bool MoveNext() {
return _baseEnumerator.MoveNext();
}
bool IEnumerator.MoveNext() {
return _baseEnumerator.MoveNext();
}
///
/// Sets the enumerator to its initial position, which is before the
/// first element in the collection.
///
public void Reset() {
_baseEnumerator.Reset();
}
void IEnumerator.Reset() {
_baseEnumerator.Reset();
}
#endregion Implementation of IEnumerator
#region Private Instance Fields
private IEnumerator _baseEnumerator;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.NUnit/FormatterDataCollection.cs 0000644 0001750 0001750 00000021774 11757302274 022627 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
namespace NAnt.NUnit.Types {
///
/// Contains a strongly typed collection of objects.
///
[Serializable]
public class FormatterDataCollection : CollectionBase {
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public FormatterDataCollection() {
}
///
/// Initializes a new instance of the class
/// with the specified instance.
///
public FormatterDataCollection(FormatterDataCollection value) {
AddRange(value);
}
///
/// Initializes a new instance of the class
/// with the specified array of instances.
///
public FormatterDataCollection(FormatterData[] value) {
AddRange(value);
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets or sets the element at the specified index.
///
/// The zero-based index of the element to get or set.
[System.Runtime.CompilerServices.IndexerName("Item")]
public FormatterData this[int index] {
get {return ((FormatterData)(base.List[index]));}
set {base.List[index] = value;}
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Adds a to the end of the collection.
///
/// The to be added to the end of the collection.
/// The position into which the new element was inserted.
public int Add(FormatterData item) {
return base.List.Add(item);
}
///
/// Adds the elements of a array to the end of the collection.
///
/// The array of elements to be added to the end of the collection.
public void AddRange(FormatterData[] items) {
for (int i = 0; (i < items.Length); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Adds the elements of a to the end of the collection.
///
/// The to be added to the end of the collection.
public void AddRange(FormatterDataCollection items) {
for (int i = 0; (i < items.Count); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Determines whether a is in the collection.
///
/// The to locate in the collection.
///
/// if is found in the
/// collection; otherwise, .
///
public bool Contains(FormatterData item) {
return base.List.Contains(item);
}
///
/// Copies the entire collection to a compatible one-dimensional array, starting at the specified index of the target array.
///
/// The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.
/// The zero-based index in at which copying begins.
public void CopyTo(FormatterData[] array, int index) {
base.List.CopyTo(array, index);
}
///
/// Retrieves the index of a specified object in the collection.
///
/// The object for which the index is returned.
///
/// The index of the specified . If the is not currently a member of the collection, it returns -1.
///
public int IndexOf(FormatterData item) {
return base.List.IndexOf(item);
}
///
/// Inserts a into the collection at the specified index.
///
/// The zero-based index at which should be inserted.
/// The to insert.
public void Insert(int index, FormatterData item) {
base.List.Insert(index, item);
}
///
/// Returns an enumerator that can iterate through the collection.
///
///
/// A for the entire collection.
///
public new FormatterDataEnumerator GetEnumerator() {
return new FormatterDataEnumerator(this);
}
///
/// Removes a member from the collection.
///
/// The to remove from the collection.
public void Remove(FormatterData item) {
base.List.Remove(item);
}
#endregion Public Instance Methods
}
///
/// Enumerates the elements of a .
///
public class FormatterDataEnumerator : IEnumerator {
#region Internal Instance Constructors
///
/// Initializes a new instance of the class
/// with the specified .
///
/// The collection that should be enumerated.
internal FormatterDataEnumerator(FormatterDataCollection arguments) {
IEnumerable temp = (IEnumerable) (arguments);
_baseEnumerator = temp.GetEnumerator();
}
#endregion Internal Instance Constructors
#region Implementation of IEnumerator
///
/// Gets the current element in the collection.
///
///
/// The current element in the collection.
///
public FormatterData Current {
get { return (FormatterData) _baseEnumerator.Current; }
}
object IEnumerator.Current {
get { return _baseEnumerator.Current; }
}
///
/// Advances the enumerator to the next element of the collection.
///
///
/// if the enumerator was successfully advanced
/// to the next element; if the enumerator has
/// passed the end of the collection.
///
public bool MoveNext() {
return _baseEnumerator.MoveNext();
}
bool IEnumerator.MoveNext() {
return _baseEnumerator.MoveNext();
}
///
/// Sets the enumerator to its initial position, which is before the
/// first element in the collection.
///
public void Reset() {
_baseEnumerator.Reset();
}
void IEnumerator.Reset() {
_baseEnumerator.Reset();
}
#endregion Implementation of IEnumerator
#region Private Instance Fields
private IEnumerator _baseEnumerator;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit2/ 0000755 0001750 0001750 00000000000 11757310030 016620 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.NUnit/NUnit2/NAnt.NUnit2.csproj 0000644 0001750 0001750 00000012054 11757302274 022035 0 ustar jtaylor jtaylor
DebugAnyCPU2.0{47503BEE-27D9-4D1C-B8E1-6C9CCC19AEAA}NAnt.NUnit2NAnt.NUnit2TasksLibraryOnSuccessfulBuildfalse8.0.50727v2.02.0publish\trueDiskfalseForeground7Daysfalsefalsetrue01.0.0.%2afalsefalsetruetruefullfalse4..\..\build\Debug\AllRules.rulesetTRACE;DEBUG..\..\build\Debug\NAnt.NUnit2Tasks.xmltruepdbonlytrue..\..\build\Release\4AllRules.rulesetTRACE..\..\build\Release\NAnt.NUnit2Tasks.xml..\..\..\lib\common\2.0\nunit.core.dll..\..\..\lib\common\2.0\nunit.core.interfaces.dll..\..\..\lib\common\2.0\nunit.framework.dll..\..\..\lib\common\2.0\nunit.util.dll
CommonAssemblyInfo.cs
False.NET Framework 3.5 SP1 Client ProfilefalseFalse.NET Framework 3.5 SP1trueFalseWindows Installer 3.1true{8F5F8375-4097-4952-B860-784EB9961ABE}NAnt.Core{B50A1067-785B-4686-8FFC-5AF424BEF163}NAnt.DotNet{00F5C075-9874-4BCE-909A-99C1F600E047}NAnt.NUnit nant-0.92-rc1/src/NAnt.NUnit/NUnit2/NUNit2TestCollection.cs 0000644 0001750 0001750 00000021552 11757302274 023122 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
namespace NAnt.NUnit2.Types {
///
/// Contains a strongly typed collection of objects.
///
[Serializable]
public class NUnit2TestCollection : CollectionBase {
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public NUnit2TestCollection() {
}
///
/// Initializes a new instance of the class
/// with the specified instance.
///
public NUnit2TestCollection(NUnit2TestCollection value) {
AddRange(value);
}
///
/// Initializes a new instance of the class
/// with the specified array of instances.
///
public NUnit2TestCollection(NUnit2Test[] value) {
AddRange(value);
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets or sets the element at the specified index.
///
/// The zero-based index of the element to get or set.
[System.Runtime.CompilerServices.IndexerName("Item")]
public NUnit2Test this[int index] {
get {return ((NUnit2Test)(base.List[index]));}
set {base.List[index] = value;}
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Adds a to the end of the collection.
///
/// The to be added to the end of the collection.
/// The position into which the new element was inserted.
public int Add(NUnit2Test item) {
return base.List.Add(item);
}
///
/// Adds the elements of a array to the end of the collection.
///
/// The array of elements to be added to the end of the collection.
public void AddRange(NUnit2Test[] items) {
for (int i = 0; (i < items.Length); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Adds the elements of a to the end of the collection.
///
/// The to be added to the end of the collection.
public void AddRange(NUnit2TestCollection items) {
for (int i = 0; (i < items.Count); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Determines whether a is in the collection.
///
/// The to locate in the collection.
///
/// if is found in the
/// collection; otherwise, .
///
public bool Contains(NUnit2Test item) {
return base.List.Contains(item);
}
///
/// Copies the entire collection to a compatible one-dimensional array, starting at the specified index of the target array.
///
/// The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.
/// The zero-based index in at which copying begins.
public void CopyTo(NUnit2Test[] array, int index) {
base.List.CopyTo(array, index);
}
///
/// Retrieves the index of a specified object in the collection.
///
/// The object for which the index is returned.
///
/// The index of the specified . If the is not currently a member of the collection, it returns -1.
///
public int IndexOf(NUnit2Test item) {
return base.List.IndexOf(item);
}
///
/// Inserts a into the collection at the specified index.
///
/// The zero-based index at which should be inserted.
/// The to insert.
public void Insert(int index, NUnit2Test item) {
base.List.Insert(index, item);
}
///
/// Returns an enumerator that can iterate through the collection.
///
///
/// A for the entire collection.
///
public new NUnit2TestEnumerator GetEnumerator() {
return new NUnit2TestEnumerator(this);
}
///
/// Removes a member from the collection.
///
/// The to remove from the collection.
public void Remove(NUnit2Test item) {
base.List.Remove(item);
}
#endregion Public Instance Methods
}
///
/// Enumerates the elements of a .
///
public class NUnit2TestEnumerator : IEnumerator {
#region Internal Instance Constructors
///
/// Initializes a new instance of the class
/// with the specified .
///
/// The collection that should be enumerated.
internal NUnit2TestEnumerator(NUnit2TestCollection arguments) {
IEnumerable temp = (IEnumerable) (arguments);
_baseEnumerator = temp.GetEnumerator();
}
#endregion Internal Instance Constructors
#region Implementation of IEnumerator
///
/// Gets the current element in the collection.
///
///
/// The current element in the collection.
///
public NUnit2Test Current {
get { return (NUnit2Test) _baseEnumerator.Current; }
}
object IEnumerator.Current {
get { return _baseEnumerator.Current; }
}
///
/// Advances the enumerator to the next element of the collection.
///
///
/// if the enumerator was successfully advanced
/// to the next element; if the enumerator has
/// passed the end of the collection.
///
public bool MoveNext() {
return _baseEnumerator.MoveNext();
}
bool IEnumerator.MoveNext() {
return _baseEnumerator.MoveNext();
}
///
/// Sets the enumerator to its initial position, which is before the
/// first element in the collection.
///
public void Reset() {
_baseEnumerator.Reset();
}
void IEnumerator.Reset() {
_baseEnumerator.Reset();
}
#endregion Implementation of IEnumerator
#region Private Instance Fields
private IEnumerator _baseEnumerator;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit2/AssemblyInfo.cs 0000644 0001750 0001750 00000002332 11757302274 021555 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Scott Hernandez (ScottHernandez@hotmail.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System.Reflection;
// This will not compile with Visual Studio. If you want to build a signed
// executable use the NAnt build file. To build under Visual Studio just
// exclude this file from the build.
[assembly: AssemblyDelaySign(false)]
//[assembly: AssemblyKeyFile(@"..\NAnt.key")]
[assembly: AssemblyKeyName("")] nant-0.92-rc1/src/NAnt.NUnit/NUnit2/Types/ 0000755 0001750 0001750 00000000000 11757310030 017724 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.NUnit/NUnit2/Types/Category.cs 0000644 0001750 0001750 00000004623 11757302274 022050 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2005 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Util;
namespace NAnt.NUnit2.Types {
///
/// Represents a certain group of test cases or fixtures.
///
public class Category : Element {
#region Private Instance Fields
private string _name;
private bool _ifDefined = true;
private bool _unlessDefined;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// A name of a category, or comma-separated list of names.
///
[TaskAttribute("name", Required=true)]
public string CategoryName {
get { return _name; }
set { _name = StringUtils.ConvertEmptyToNull(value); }
}
///
/// If then the category will be processed;
/// otherwise, skipped. The default is .
///
[TaskAttribute("if")]
[BooleanValidator()]
public bool IfDefined {
get { return _ifDefined; }
set { _ifDefined = value; }
}
///
/// If then the category will be skipped;
/// otherwise, processed. The default is .
///
[TaskAttribute("unless")]
[BooleanValidator()]
public bool UnlessDefined {
get { return _unlessDefined; }
set { _unlessDefined = value; }
}
#endregion Public Instance Properties
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit2/Types/CategoryCollection.cs 0000644 0001750 0001750 00000011727 11757302274 024067 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2005 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
// Ryan Boggs (rmboggs@users.sourceforge.net)
using System;
using System.Collections;
using System.Collections.ObjectModel;
using System.Collections.Generic;
using NAnt.Core.Util;
namespace NAnt.NUnit2.Types {
///
/// Contains a collection of elements.
///
[Serializable()]
public class CategoryCollection : Collection {
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public CategoryCollection()
: base()
{
}
///
/// Initializes a new instance of the
/// class as a wrapper for
/// the specified list.
///
///
/// The list that is wrapped by the newly created instance.
///
public CategoryCollection(IList value)
: base(value)
{
}
///
/// Initializes a new instance of the class
/// with the specified instance.
///
///
/// The collection to use to initialize the new instance with.
///
public CategoryCollection(CategoryCollection value)
: base(value)
{
}
///
/// Initializes a new instance of the class
/// with the specified array of instances.
///
///
/// The collection to use to initialize the new instance with.
///
public CategoryCollection(Category[] value)
: base()
{
AddRange(value);
}
#endregion Public Instance Constructors
#region Override implementation of Object
///
/// Returns a comma-delimited list of categories.
///
///
/// A comma-delimited list of categories, or an empty
/// if there are no categories.
///
public override string ToString() {
List categories = new List(this.Count);
foreach (Category category in this)
{
if (category.IfDefined && !category.UnlessDefined)
{
categories.Add(category.CategoryName);
}
}
return String.Join(",", categories.ToArray());
}
#endregion Override implementation of Object
#region Public Instance Properties
///
/// Gets the with the specified name.
///
/// The name of the to get.
[System.Runtime.CompilerServices.IndexerName("Item")]
public Category this[string value] {
get {
if (value != null) {
// Try to locate instance using Value
foreach (Category category in this) {
if (value.Equals(category.CategoryName)) {
return category;
}
}
}
return null;
}
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Adds the elements of a array to the end of the
/// collection.
///
///
/// The array of elements to be added to the end of
/// the collection.
///
public void AddRange(IEnumerable items)
{
foreach (Category item in items)
{
Add(item);
}
}
#endregion Public Instance Methods
}
} nant-0.92-rc1/src/NAnt.NUnit/NUnit2/Types/Categories.cs 0000644 0001750 0001750 00000005003 11757302274 022351 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2005 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.NUnit2.Tasks;
namespace NAnt.NUnit2.Types {
///
/// Controls the categories of tests to execute using the .
///
///
///
/// Only include test cases and fixtures that require no internet access.
///
///
///
///
///
/// ]]>
///
///
///
///
/// Exclude test cases and fixtures that are known to fail.
///
///
///
///
///
/// ]]>
///
///
[ElementName("categories")]
public class Categories : DataTypeBase {
#region Private Instance Fields
private CategoryCollection _includes = new CategoryCollection();
private CategoryCollection _excludes = new CategoryCollection();
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Specifies a list of categories to include.
///
[BuildElementArray("include")]
public CategoryCollection Includes {
get { return _includes; }
}
///
/// Specifies a list of categories to exclude.
///
[BuildElementArray("exclude")]
public CategoryCollection Excludes {
get { return _excludes; }
}
#endregion Public Instance Properties
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit2/NUnit2Test.cs 0000644 0001750 0001750 00000011563 11757302274 021147 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Mike Two (2@thoughtworks.com or mike2@nunit.org)
// Scott Hernandez (ScottHernandez@hotmail.com)
using System.Collections.Specialized;
using System.IO;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.DotNet.Types;
using NAnt.NUnit.Types;
using NAnt.NUnit2.Tasks;
using NAnt.NUnit2.Types;
namespace NAnt.NUnit2.Types {
///
/// Represents a test element of an .
///
[ElementName("test")]
public class NUnit2Test : Element {
#region Private Instance Fields
private FileInfo _assemblyFile;
private string _testname;
private bool _haltOnFailure = true;
private FileInfo _xsltFile;
private AssemblyFileSet _assemblies = new AssemblyFileSet();
private AssemblyFileSet _references = new AssemblyFileSet();
private FileInfo _appConfigFile;
private Categories _categories = new Categories();
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Name of the assembly to search for tests.
///
[TaskAttribute("assemblyname")]
public FileInfo AssemblyFile {
get { return _assemblyFile; }
set { _assemblyFile = value; }
}
///
/// Name of a specific testfixture to run. If not specified then all
/// testfixtures are run.
///
[TaskAttribute("testname")]
public string TestName {
get { return _testname; }
set { _testname = value; }
}
///
/// Assemblies to include in test.
///
[BuildElement("assemblies")]
public AssemblyFileSet Assemblies {
get { return _assemblies; }
set { _assemblies = value; }
}
///
/// Assemblies to scan for missing assembly references.
///
[BuildElement("references")]
public AssemblyFileSet References {
get { return _references; }
set { _references = value; }
}
///
/// Categories of test cases to include or exclude.
///
[BuildElement("categories")]
public Categories Categories {
get { return _categories; }
set { _categories = value; }
}
///
/// Build fails on failure. The default is .
///
[TaskAttribute("haltonfailure")]
[BooleanValidator()]
public bool HaltOnFailure {
get { return _haltOnFailure; }
set { _haltOnFailure = value; }
}
///
/// XSLT transform file to use when using the
/// formatter.
///
[TaskAttribute("transformfile")]
public FileInfo XsltFile {
get { return _xsltFile; }
set { _xsltFile = value; }
}
///
/// The application configuration file to use for the NUnit test domain.
/// If not specified, NAnt will try to use a configuration name matching
/// the file name of the assembly with extension ".config".
///
[TaskAttribute("appconfig")]
public FileInfo AppConfigFile {
get { return _appConfigFile; }
set { _appConfigFile = value; }
}
///
/// Gets all assemblies specified for these tests.
///
///
/// All assemblies specified for these tests.
///
public StringCollection TestAssemblies {
get {
StringCollection files = new StringCollection();
if (AssemblyFile != null) {
files.Add(AssemblyFile.FullName);
} else {
files = Assemblies.FileNames;
}
return files;
}
}
#endregion Public Instance Properties
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit2/NUnit2TestDomain.cs 0000644 0001750 0001750 00000030370 11757302274 022274 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Tomas Restrepo (tomasr@mvps.org)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.Remoting;
using NUnit.Core;
using System.Security;
using System.Security.Permissions;
using System.Security.Policy;
namespace NAnt.NUnit2.Tasks {
///
/// Custom TestDomain, similar to the one included with NUnit, in order
/// to workaround some limitations in it.
///
internal class NUnit2TestDomain {
#region Public Instance Constructors
///
/// Initializes a new instance of the
/// class.
///
public NUnit2TestDomain() {
}
#endregion Public Instance Constructors
#region Public Instance Methods
///
/// Runs a single testcase.
///
/// The test assembly.
/// The application configuration file for the test domain.
/// List of files to scan for missing assembly references.
///
/// The result of the test.
///
public TestRunner CreateRunner(FileInfo assemblyFile, FileInfo configFile, StringCollection referenceAssemblies) {
// create test domain
_domain = CreateDomain(assemblyFile.Directory, assemblyFile,
configFile);
// assemble directories which can be probed for missing unresolved
// assembly references
string[] probePaths = null;
if (AppDomain.CurrentDomain.SetupInformation.PrivateBinPath != null) {
string [] privateBinPaths = AppDomain.CurrentDomain.SetupInformation.PrivateBinPath.Split(Path.PathSeparator);
probePaths = new string [privateBinPaths.Length + 1];
for (int i = 0; i < privateBinPaths.Length; i++) {
probePaths[i] = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
privateBinPaths[i]);
}
} else {
probePaths = new string[1];
}
string[] references = new string[referenceAssemblies.Count];
referenceAssemblies.CopyTo (references, 0);
// add base directory of current AppDomain as probe path
probePaths [probePaths.Length - 1] = AppDomain.CurrentDomain.BaseDirectory;
// create an instance of our custom Assembly Resolver in the target domain.
#if NET_4_0
_domain.CreateInstanceFrom(Assembly.GetExecutingAssembly().CodeBase,
typeof(AssemblyResolveHandler).FullName,
false,
BindingFlags.Public | BindingFlags.Instance,
null,
new object[] {probePaths, references},
CultureInfo.InvariantCulture,
null);
#else
_domain.CreateInstanceFrom(Assembly.GetExecutingAssembly().CodeBase,
typeof(AssemblyResolveHandler).FullName,
false,
BindingFlags.Public | BindingFlags.Instance,
null,
new object[] {probePaths, references},
CultureInfo.InvariantCulture,
null,
AppDomain.CurrentDomain.Evidence);
#endif
// create testrunner
return CreateTestRunner(_domain);
}
public void Unload() {
if (_domain != null) {
try {
AppDomain.Unload(_domain);
} catch (CannotUnloadAppDomainException) {
// ignore exceptions during unload, this matches the
// behaviour of the NUnit TestDomain
} finally {
_domain = null;
}
}
}
#endregion Public Instance Methods
#region Private Instance Methods
private AppDomain CreateDomain(DirectoryInfo basedir, FileInfo assemblyFile, FileInfo configFile) {
// spawn new domain in specified directory
AppDomainSetup domSetup = new AppDomainSetup();
domSetup.ApplicationBase = basedir.FullName;
domSetup.ApplicationName = "NAnt NUnit Remote Domain";
// use explicitly specified configuration file, or fall back to
// configuration file for given assembly file
if (configFile != null) {
domSetup.ConfigurationFile = configFile.FullName;
} else {
domSetup.ConfigurationFile = assemblyFile.FullName + ".config";
}
PermissionSet myDomainPermSet = new PermissionSet(PermissionState.Unrestricted);
return AppDomain.CreateDomain(domSetup.ApplicationName, AppDomain.CurrentDomain.Evidence, domSetup, myDomainPermSet);
}
private RemoteTestRunner CreateTestRunner(AppDomain domain) {
ObjectHandle oh;
Type rtrType = typeof(RemoteTestRunner);
#if NET_4_0
oh = domain.CreateInstance(
rtrType.Assembly.FullName,
rtrType.FullName,
false,
BindingFlags.Public | BindingFlags.Instance,
null,
null,
CultureInfo.InvariantCulture,
null);
#else
oh = domain.CreateInstance(
rtrType.Assembly.FullName,
rtrType.FullName,
false,
BindingFlags.Public | BindingFlags.Instance,
null,
null,
CultureInfo.InvariantCulture,
null,
AppDomain.CurrentDomain.Evidence);
#endif
return (RemoteTestRunner) oh.Unwrap();
}
#endregion Private Instance Methods
#region Private Instance Fields
private AppDomain _domain;
#endregion Private Instance Fields
///
/// Helper class called when an assembly resolve event is raised.
///
[Serializable()]
private class AssemblyResolveHandler {
#region Public Instance Constructors
///
/// Initializes an instanse of the
/// class.
///
public AssemblyResolveHandler(string[] probePaths, string[] referenceAssemblies) {
_assemblyCache = new Hashtable();
_probePaths = probePaths;
_referenceAssemblies = referenceAssemblies;
// attach handlers for the current domain.
AppDomain.CurrentDomain.AssemblyResolve +=
new ResolveEventHandler(ResolveAssembly);
AppDomain.CurrentDomain.AssemblyLoad +=
new AssemblyLoadEventHandler(AssemblyLoad);
}
#endregion Public Instance Constructors
#region Public Instance Methods
///
/// Called back when the CLR cannot resolve a given assembly.
///
/// The source of the event.
/// A that contains the event data.
///
/// The nunit.framework we know to be in NAnts bin directory, if
/// that is the assembly that needs to be resolved; otherwise,
/// .
///
public Assembly ResolveAssembly(Object sender, ResolveEventArgs args) {
bool isFullName = args.Name.IndexOf("Version=") != -1;
// find assembly in cache
if (isFullName) {
if (_assemblyCache.Contains(args.Name)) {
// return assembly from cache
return (Assembly) _assemblyCache[args.Name];
}
} else {
foreach (Assembly assembly in _assemblyCache.Values) {
if (assembly.GetName(false).Name == args.Name) {
// return assembly from cache
return assembly;
}
}
}
// find assembly in reference assemblies
foreach (string assemblyFile in _referenceAssemblies) {
Assembly assembly = TryLoad (assemblyFile, args.Name, isFullName);
if (assembly != null)
return assembly;
}
// find assembly in probe paths
foreach (string path in _probePaths) {
if (!Directory.Exists(path)) {
continue;
}
string[] assemblies = Directory.GetFiles(path, "*.dll");
foreach (string assemblyFile in assemblies) {
Assembly assembly = TryLoad (assemblyFile, args.Name, isFullName);
if (assembly != null)
return assembly;
}
}
// assembly reference could not be resolved
return null;
}
static Assembly TryLoad (string assemblyFile, string name, bool isFullName) {
Assembly assembly = null;
try {
AssemblyName assemblyName = AssemblyName.GetAssemblyName(assemblyFile);
if (isFullName) {
if (assemblyName.FullName == name) {
assembly = Assembly.LoadFrom(assemblyFile);
}
} else {
if (assemblyName.Name == name) {
assembly = Assembly.LoadFrom(assemblyFile);
}
}
} catch {
// ignore assembly load failures
}
return assembly;
}
///
/// Occurs when an assembly is loaded. The loaded assembly is added
/// to the assembly cache.
///
/// The source of the event.
/// An that contains the event data.
private void AssemblyLoad(object sender, AssemblyLoadEventArgs args) {
// store assembly in cache
_assemblyCache[args.LoadedAssembly.FullName] = args.LoadedAssembly;
}
#endregion Public Instance Methods
#region Private Instance Fields
///
/// Holds the list of directories that will be scanned for missing
/// assembly references.
///
private readonly string[] _probePaths;
///
/// Holds the list of assemblies that can be scanned for missing
/// assembly references.
///
private readonly string[] _referenceAssemblies;
///
/// Holds the loaded assemblies.
///
private readonly Hashtable _assemblyCache;
#endregion Private Instance Fields
}
}
}
nant-0.92-rc1/src/NAnt.NUnit/NUnit2/NUnit2Task.cs 0000644 0001750 0001750 00000054154 11757302274 021135 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Mike Two (2@thoughtworks.com or mike2@nunit.org)
// Tomas Restrepo (tomasr@mvps.org)
// Ryan Boggs (rmboggs@users.sourceforge.net)
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Resources;
using System.Text;
using System.Xml;
using System.Xml.Xsl;
using System.Xml.XPath;
using NUnit.Core;
using NUnit.Core.Filters;
using TestOutput = NUnit.Core.TestOutput;
using NUnit.Framework;
using NUnit.Util;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Util;
using NAnt.NUnit.Types;
using NAnt.NUnit2.Types;
namespace NAnt.NUnit2.Tasks {
///
/// Runs tests using the NUnit V2.6 framework.
///
///
///
/// The attribute is only useful when more
/// than one test suite is used, and you want to continue running other
/// test suites although a test failed.
///
///
/// Set to to
/// ignore any errors and continue the build.
///
///
/// In order to run a test assembly built with NUnit 2.0 or 2.1 using
/// , you must add the following node to your
/// test config file :
///
///
///
/// ...
///
///
///
///
///
///
///
///
///
/// ...
///
/// ]]>
///
///
/// See the NUnit home page for more
/// information.
///
///
///
///
/// Run tests in the MyProject.Tests.dll assembly.
///
///
///
///
///
///
/// ]]>
///
///
///
///
/// Only run tests that are not known to fail in files listed in the tests.txt
/// file.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("nunit2")]
public class NUnit2Task : Task {
#region Private Instance Fields
private bool _labels = false;
private bool _haltOnFailure = false;
private List _tests = new List();
private List _formatterElements = new List();
//private NUnit2TestCollection _tests = new NUnit2TestCollection();
//private FormatterElementCollection _formatterElements = new FormatterElementCollection();
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Stop the test run if a test fails. The default is .
///
[TaskAttribute("haltonfailure")]
[BooleanValidator()]
public bool HaltOnFailure {
get { return _haltOnFailure; }
set { _haltOnFailure = value; }
}
///
/// Indicate whether or not to label the text output as the tests run.
///
[TaskAttribute("labels")]
[BooleanValidator()]
public bool Labels {
get { return _labels; }
set { _labels = value; }
}
///
/// Tests to run.
///
[BuildElementArray("test")]
public List Tests {
get { return _tests; }
}
///
/// Formatters to output results of unit tests.
///
[BuildElementArray("formatter")]
public List FormatterElements {
get { return _formatterElements; }
}
#endregion Public Instance Properties
#region Override implementation of Task
///
/// Runs the tests and sets up the formatters.
///
protected override void ExecuteTask() {
if (FormatterElements.Count == 0) {
FormatterElement defaultFormatter = new FormatterElement();
defaultFormatter.Project = Project;
defaultFormatter.NamespaceManager = NamespaceManager;
defaultFormatter.Type = FormatterType.Plain;
defaultFormatter.UseFile = false;
FormatterElements.Add(defaultFormatter);
Log(Level.Warning, "No element was specified." +
" A plain-text formatter was added to prevent losing output of the" +
" test results.");
Log(Level.Warning, "Add a element to the" +
" task to prevent this warning from being output and" +
" to ensure forward compatibility with future revisions of NAnt.");
}
LogWriter logWriter = new LogWriter(this, Level.Info, CultureInfo.InvariantCulture);
EventListener listener = GetListener(logWriter);
foreach (NUnit2Test testElement in Tests) {
// Setup the test filter var to setup include/exclude filters.
ITestFilter testFilter = null;
// If the include categories contains values, setup the category
// filter with the include categories.
string includes = testElement.Categories.Includes.ToString();
if (!String.IsNullOrEmpty(includes))
{
testFilter = new CategoryFilter(includes.Split(','));
}
else
{
// If the include categories does not have includes but
// contains excludes, setup the category filter with the excludes
// and use the Not filter to tag the categories for exclude.
string excludes = testElement.Categories.Excludes.ToString();
if (!String.IsNullOrEmpty(excludes))
{
ITestFilter excludeFilter = new CategoryFilter(excludes.Split(','));
testFilter = new NotFilter(excludeFilter);
}
else
{
// If the categories do not contain includes or excludes,
// assign the testFilter var with an empty filter.
testFilter = TestFilter.Empty;
}
}
foreach (string testAssembly in testElement.TestAssemblies) {
// Setup the NUnit2TestDomain var.
NUnit2TestDomain domain = new NUnit2TestDomain();
// Setup the TestPackage var to use with the testrunner var
TestPackage package = new TestPackage(testAssembly);
try {
// Create the TestRunner var
TestRunner runner = domain.CreateRunner(
new FileInfo(testAssembly),
testElement.AppConfigFile,
testElement.References.FileNames);
// If the name of the current test element is not null,
// use it for the package test name.
if (!String.IsNullOrEmpty(testElement.TestName))
{
package.TestName = testElement.TestName;
}
// Bool var containing the result of loading the test package
// in the TestRunner var.
bool successfulLoad = runner.Load(package);
// If the test package load was successful, proceed with the
// testing.
if (successfulLoad)
{
// If the runner does not contain any tests, proceed
// to the next assembly.
if (runner.Test == null) {
Log(Level.Warning, "Assembly \"{0}\" contains no tests.",
testAssembly);
continue;
}
// Setup and run tests
TestResult result = runner.Run(listener, testFilter,
true, GetLoggingThreshold());
// flush test output to log
logWriter.Flush();
// format test results using specified formatters
FormatResult(testElement, result);
if (result.IsFailure &&
(testElement.HaltOnFailure || HaltOnFailure)) {
throw new BuildException("Tests Failed.", Location);
}
}
else
{
// If the package load failed, throw a build exception.
throw new BuildException("Test Package Load Failed.", Location);
}
} catch (BuildException) {
// re-throw build exceptions
throw;
} catch (Exception ex) {
if (!FailOnError) {
// just log error and continue with next test
// TODO: (RMB) Need to make sure that this is the correct way to proceed with displaying NUnit errors.
string logMessage =
String.Concat("[", Name, "] NUnit Error: ", ex.ToString());
Log(Level.Error, logMessage.PadLeft(Project.IndentationSize));
continue;
}
Version nunitVersion = typeof(TestResult).Assembly.GetName().Version;
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Failure executing test(s). If you assembly is not built using"
+ " NUnit version {0}, then ensure you have redirected assembly"
+ " bindings. Consult the documentation of the task"
+ " for more information.", nunitVersion), Location, ex);
} finally {
domain.Unload();
// flush test output to log
logWriter.Flush();
}
}
}
}
#endregion Override implementation of Task
#region Protected Instance Methods
///
/// Gets a new EventListener to use for the unit tests.
///
///
/// A new EventListener created with a new EventCollector that
/// is initialized with .
///
///
/// Log writer to send test output to.
///
protected virtual EventListener GetListener(LogWriter logWriter)
{
return new EventCollector(logWriter, logWriter, _labels);
}
#endregion Protected Instance Methods
#region Private Instance Methods
///
/// Gets the logging threshold to use for a test runner based on
/// the current threshold of this task.
///
///
/// The logging threshold to use when running a test runner.
///
private LoggingThreshold GetLoggingThreshold()
{
LoggingThreshold result;
// TODO: (RMB) May need to re-evaluate these mappings
switch (Threshold) {
case Level.None:
result = LoggingThreshold.Fatal;
break;
case Level.Info:
result = LoggingThreshold.Info;
break;
case Level.Verbose:
result = LoggingThreshold.All;
break;
case Level.Debug:
result = LoggingThreshold.Debug;
break;
case Level.Warning:
result = LoggingThreshold.Warn;
break;
case Level.Error:
result = LoggingThreshold.Error;
break;
default:
result = LoggingThreshold.Off;
break;
}
return result;
}
private void FormatResult(NUnit2Test testElement, TestResult result) {
// temp file for storing test results
string xmlResultFile = Path.GetTempFileName();
try {
XmlResultWriter resultWriter = new XmlResultWriter(xmlResultFile);
resultWriter.SaveTestResult(result);
foreach (FormatterElement formatter in FormatterElements) {
// permanent file for storing test results
string outputFile = result.Name + "-results" + formatter.Extension;
if (formatter.Type == FormatterType.Xml) {
if (formatter.UseFile) {
if (formatter.OutputDirectory != null) {
// ensure output directory exists
if (!formatter.OutputDirectory.Exists) {
formatter.OutputDirectory.Create();
}
// combine output directory and result filename
outputFile = Path.Combine(formatter.OutputDirectory.FullName,
Path.GetFileName(outputFile));
}
// copy the temp result file to permanent location
File.Copy(xmlResultFile, outputFile, true);
} else {
using (StreamReader reader = new StreamReader(xmlResultFile)) {
// strip off the xml header
reader.ReadLine();
StringBuilder builder = new StringBuilder();
while (reader.Peek() > -1) {
builder.Append(reader.ReadLine().Trim()).Append(
Environment.NewLine);
}
Log(Level.Info, builder.ToString());
}
}
} else if (formatter.Type == FormatterType.Plain) {
TextWriter writer;
if (formatter.UseFile) {
if (formatter.OutputDirectory != null) {
// ensure output directory exists
if (!formatter.OutputDirectory.Exists) {
formatter.OutputDirectory.Create();
}
// combine output directory and result filename
outputFile = Path.Combine(formatter.OutputDirectory.FullName,
Path.GetFileName(outputFile));
}
writer = new StreamWriter(outputFile);
} else {
writer = new LogWriter(this, Level.Info, CultureInfo.InvariantCulture);
}
CreateSummaryDocument(xmlResultFile, writer, testElement);
writer.Close();
}
}
} catch (Exception ex) {
throw new BuildException("Test results could not be formatted.",
Location, ex);
} finally {
// make sure temp file with test results is removed
File.Delete(xmlResultFile);
}
}
private void CreateSummaryDocument(string resultFile, TextWriter writer, NUnit2Test test) {
XPathDocument originalXPathDocument = new XPathDocument(resultFile);
// Using XslTransform instead of XslCompiledTransform because the latter
// does not display nunit output for unknown reasons.
XslTransform summaryXslTransform = new XslTransform();
XmlTextReader transformReader = GetTransformReader(test);
summaryXslTransform.Load(transformReader);
summaryXslTransform.Transform(originalXPathDocument, null, writer);
}
private XmlTextReader GetTransformReader(NUnit2Test test) {
XmlTextReader transformReader;
if (test.XsltFile == null) {
Assembly assembly = Assembly.GetAssembly(typeof(XmlResultWriter));
ResourceManager resourceManager = new ResourceManager("NUnit.Util.Transform", assembly);
string xmlData = (string) resourceManager.GetObject("Summary.xslt", CultureInfo.InvariantCulture);
transformReader = new XmlTextReader(new StringReader(xmlData));
} else {
if (!test.XsltFile.Exists) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Transform file '{0}' does not exist.", test.XsltFile.FullName),
Location);
}
transformReader = new XmlTextReader(test.XsltFile.FullName);
}
return transformReader;
}
#endregion Private Instance Methods
private class EventCollector : MarshalByRefObject, EventListener {
private TextWriter outWriter;
private TextWriter errorWriter;
private string currentTestName;
private bool _printLabel;
public EventCollector(TextWriter outWriter, TextWriter errorWriter)
: this(outWriter, errorWriter, false) {}
public EventCollector(TextWriter outWriter, TextWriter errorWriter, bool labels) {
this.outWriter = outWriter;
this.errorWriter = errorWriter;
this.currentTestName = string.Empty;
this._printLabel = labels;
}
public void RunStarted( string name, int testCount ) {
}
public void RunFinished(TestResult results) {
}
public void RunFinished(Exception exception) {
}
public void TestFinished(TestResult result) {
currentTestName = string.Empty;
}
public void TestStarted(TestName testName) {
currentTestName = testName.FullName;
if (this._printLabel) {
outWriter.WriteLine("***** {0}", currentTestName );
}
}
public void SuiteStarted(TestName testName) {
}
public void SuiteFinished(TestResult result) {
}
public void UnhandledException( Exception exception ) {
string msg = string.Format("##### Unhandled Exception while running {0}", currentTestName);
errorWriter.WriteLine(msg);
errorWriter.WriteLine(exception.ToString());
}
public void TestOutput(TestOutput output) {
switch (output.Type) {
case TestOutputType.Out:
outWriter.Write(output.Text);
break;
case TestOutputType.Error:
errorWriter.Write(output.Text);
break;
}
}
public override object InitializeLifetimeService() {
return null;
}
}
}
}
nant-0.92-rc1/src/NAnt.NUnit/AssemblyInfo.cs 0000644 0001750 0001750 00000002332 11757302274 020436 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Scott Hernandez (ScottHernandez@hotmail.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System.Reflection;
// This will not compile with Visual Studio. If you want to build a signed
// executable use the NAnt build file. To build under Visual Studio just
// exclude this file from the build.
[assembly: AssemblyDelaySign(false)]
//[assembly: AssemblyKeyFile(@"..\NAnt.key")]
[assembly: AssemblyKeyName("")] nant-0.92-rc1/src/NAnt.NUnit/FormatterData.cs 0000644 0001750 0001750 00000005555 11757302274 020612 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Tomas Restrepo (tomasr@mvps.org)
using System;
using System.IO;
namespace NAnt.NUnit.Types {
///
/// Carries data specified through the formatter element.
///
[Serializable]
public class FormatterData {
#region Private Instance Fields
private string _extension;
private bool _usefile;
private FormatterType _formatterType = FormatterType.Plain;
private DirectoryInfo _outputDirectory;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Gets or sets the type of the formatter.
///
/// The type of the formatter.
public FormatterType Type {
get { return _formatterType; }
set { _formatterType = value; }
}
///
/// Gets or sets a value indicating whether output should be persisted
/// to a file.
///
///
/// if output should be written to a file; otherwise,
/// . The default is .
///
public bool UseFile {
get { return _usefile; }
set { _usefile = value; }
}
///
/// Gets or sets the extension to append to the output filename.
///
/// The extension to append to the output filename.
public string Extension {
get { return _extension; }
set { _extension = value; }
}
///
/// Gets or sets the directory where the output file should be written
/// to, if is .
///
///
/// The directory where the output file should be written to.
///
public DirectoryInfo OutputDirectory {
get { return _outputDirectory; }
set { _outputDirectory = value; }
}
#endregion Public Instance Properties
}
}
nant-0.92-rc1/src/NAnt.Compression/ 0000755 0001750 0001750 00000000000 11757310030 016745 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.Compression/AssemblyInfo.cs 0000644 0001750 0001750 00000002332 11757302272 021700 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Scott Hernandez (ScottHernandez@hotmail.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System.Reflection;
// This will not compile with Visual Studio. If you want to build a signed
// executable use the NAnt build file. To build under Visual Studio just
// exclude this file from the build.
[assembly: AssemblyDelaySign(false)]
//[assembly: AssemblyKeyFile(@"..\NAnt.key")]
[assembly: AssemblyKeyName("")] nant-0.92-rc1/src/NAnt.Compression/Types/ 0000755 0001750 0001750 00000000000 11757310030 020051 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.Compression/Types/TarFileSetCollection.cs 0000644 0001750 0001750 00000022252 11757302272 024432 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
namespace NAnt.Compression.Types {
///
/// Contains a collection of elements.
///
[Serializable()]
public class TarFileSetCollection : CollectionBase {
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public TarFileSetCollection() {
}
///
/// Initializes a new instance of the class
/// with the specified instance.
///
public TarFileSetCollection(TarFileSetCollection value) {
AddRange(value);
}
///
/// Initializes a new instance of the class
/// with the specified array of instances.
///
public TarFileSetCollection(TarFileSet[] value) {
AddRange(value);
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets or sets the element at the specified index.
///
/// The zero-based index of the element to get or set.
[System.Runtime.CompilerServices.IndexerName("Item")]
public TarFileSet this[int index] {
get { return ((TarFileSet)(base.List[index])); }
set { base.List[index] = value; }
}
///
/// Get the total number of files that are represented by the
/// filesets in this collection.
///
public int FileCount {
get {
int fileCount = 0;
foreach (TarFileSet fileset in base.List) {
fileCount += fileset.FileNames.Count;
}
return fileCount;
}
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Adds a to the end of the collection.
///
/// The to be added to the end of the collection.
/// The position into which the new element was inserted.
public int Add(TarFileSet item) {
return base.List.Add(item);
}
///
/// Adds the elements of a array to the end of the collection.
///
/// The array of elements to be added to the end of the collection.
public void AddRange(TarFileSet[] items) {
for (int i = 0; (i < items.Length); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Adds the elements of a to the end of the collection.
///
/// The to be added to the end of the collection.
public void AddRange(TarFileSetCollection items) {
for (int i = 0; (i < items.Count); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Determines whether a is in the collection.
///
/// The to locate in the collection.
///
/// if is found in the
/// collection; otherwise, .
///
public bool Contains(TarFileSet item) {
return base.List.Contains(item);
}
///
/// Copies the entire collection to a compatible one-dimensional array, starting at the specified index of the target array.
///
/// The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.
/// The zero-based index in at which copying begins.
public void CopyTo(TarFileSet[] array, int index) {
base.List.CopyTo(array, index);
}
///
/// Retrieves the index of a specified object in the collection.
///
/// The object for which the index is returned.
///
/// The index of the specified . If the is not currently a member of the collection, it returns -1.
///
public int IndexOf(TarFileSet item) {
return base.List.IndexOf(item);
}
///
/// Inserts a into the collection at the specified index.
///
/// The zero-based index at which should be inserted.
/// The to insert.
public void Insert(int index, TarFileSet item) {
base.List.Insert(index, item);
}
///
/// Returns an enumerator that can iterate through the collection.
///
///
/// A for the entire collection.
///
public new TarFileSetEnumerator GetEnumerator() {
return new TarFileSetEnumerator(this);
}
///
/// Removes a member from the collection.
///
/// The to remove from the collection.
public void Remove(TarFileSet item) {
base.List.Remove(item);
}
#endregion Public Instance Methods
}
///
/// Enumerates the elements of a .
///
public class TarFileSetEnumerator : IEnumerator {
#region Internal Instance Constructors
///
/// Initializes a new instance of the class
/// with the specified .
///
/// The collection that should be enumerated.
internal TarFileSetEnumerator(TarFileSetCollection TarFileSets) {
IEnumerable temp = (IEnumerable) (TarFileSets);
_baseEnumerator = temp.GetEnumerator();
}
#endregion Internal Instance Constructors
#region Implementation of IEnumerator
///
/// Gets the current element in the collection.
///
///
/// The current element in the collection.
///
public TarFileSet Current {
get { return (TarFileSet) _baseEnumerator.Current; }
}
object IEnumerator.Current {
get { return _baseEnumerator.Current; }
}
///
/// Advances the enumerator to the next element of the collection.
///
///
/// if the enumerator was successfully advanced
/// to the next element; if the enumerator has
/// passed the end of the collection.
///
public bool MoveNext() {
return _baseEnumerator.MoveNext();
}
bool IEnumerator.MoveNext() {
return _baseEnumerator.MoveNext();
}
///
/// Sets the enumerator to its initial position, which is before the
/// first element in the collection.
///
public void Reset() {
_baseEnumerator.Reset();
}
void IEnumerator.Reset() {
_baseEnumerator.Reset();
}
#endregion Implementation of IEnumerator
#region Private Instance Fields
private IEnumerator _baseEnumerator;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.Compression/Types/DuplicateHandling.cs 0000644 0001750 0001750 00000005731 11757302272 023776 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2003 Scott Hernandez
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.ComponentModel;
using System.Globalization;
namespace NAnt.Compression.Types {
///
/// Specifies how entries with the same name should be processed.
///
[TypeConverter(typeof(DuplicateHandlingConverter))]
public enum DuplicateHandling {
///
/// Overwrite existing entry with same name.
///
Add = 0,
///
/// Preserve existing entry with the same name.
///
Preserve = 1,
///
/// Report failure when two entries have the same name.
///
Fail = 2
}
///
/// Specialized for
/// that ignores case when converting from string.
///
internal class DuplicateHandlingConverter : EnumConverter {
///
/// Initializes a new instance of the
/// class.
///
public DuplicateHandlingConverter() : base(typeof(DuplicateHandling)) {
}
///
/// Converts the given object to the type of this converter, using the
/// specified context and culture information.
///
/// An that provides a format context.
/// A object. If a is passed, the current culture is assumed.
/// The to convert.
///
/// An that represents the converted value.
///
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) {
string stringValue = value as string;
if (stringValue != null)
return Enum.Parse(EnumType, stringValue, true);
// default to EnumConverter behavior
return base.ConvertFrom(context, culture, value);
}
}
}
nant-0.92-rc1/src/NAnt.Compression/Types/TarCompressionMethod.cs 0000644 0001750 0001750 00000004237 11757302272 024530 0 ustar jtaylor jtaylor using System;
using System.ComponentModel;
using System.Globalization;
using NAnt.Compression.Tasks;
namespace NAnt.Compression.Types {
///
/// Specifies the compression methods supported by
/// and .
///
[TypeConverter(typeof(TarCompressionMethodConverter))]
public enum TarCompressionMethod {
///
/// No compression.
///
None = 0,
///
/// GZIP compression.
///
GZip = 1,
///
/// BZIP2 compression.
///
BZip2 = 2
}
///
/// Specialized for
/// that ignores case when converting from string.
///
internal class TarCompressionMethodConverter : EnumConverter {
///
/// Initializes a new instance of the
/// class.
///
public TarCompressionMethodConverter() : base(typeof(TarCompressionMethod)) {
}
///
/// Converts the given object to the type of this converter, using the
/// specified context and culture information.
///
/// An that provides a format context.
/// A object. If a is passed, the current culture is assumed.
/// The to convert.
///
/// An that represents the converted value.
///
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) {
string stringValue = value as string;
if (stringValue != null)
return Enum.Parse(EnumType, stringValue, true);
// default to EnumConverter behavior
return base.ConvertFrom(context, culture, value);
}
}
}
nant-0.92-rc1/src/NAnt.Compression/Types/ZipFileSetCollection.cs 0000644 0001750 0001750 00000022262 11757302272 024447 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
namespace NAnt.Compression.Types {
///
/// Contains a collection of elements.
///
[Serializable()]
public class ZipFileSetCollection : CollectionBase {
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public ZipFileSetCollection() {
}
///
/// Initializes a new instance of the class
/// with the specified instance.
///
public ZipFileSetCollection(ZipFileSetCollection value) {
AddRange(value);
}
///
/// Initializes a new instance of the class
/// with the specified array of instances.
///
public ZipFileSetCollection(ZipFileSet[] value) {
AddRange(value);
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets or sets the element at the specified index.
///
/// The zero-based index of the element to get or set.
[System.Runtime.CompilerServices.IndexerName("Item")]
public ZipFileSet this[int index] {
get { return ((ZipFileSet)(base.List[index])); }
set { base.List[index] = value; }
}
///
/// Get the total number of files that are represented by the
/// filesets in this collection.
///
public int FileCount {
get {
int fileCount = 0;
foreach (ZipFileSet fileset in base.List) {
fileCount += fileset.FileNames.Count;
}
return fileCount;
}
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Adds a to the end of the collection.
///
/// The to be added to the end of the collection.
/// The position into which the new element was inserted.
public int Add(ZipFileSet item) {
return base.List.Add(item);
}
///
/// Adds the elements of a array to the end of the collection.
///
/// The array of elements to be added to the end of the collection.
public void AddRange(ZipFileSet[] items) {
for (int i = 0; (i < items.Length); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Adds the elements of a to the end of the collection.
///
/// The to be added to the end of the collection.
public void AddRange(ZipFileSetCollection items) {
for (int i = 0; (i < items.Count); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Determines whether a is in the collection.
///
/// The to locate in the collection.
///
/// if is found in the
/// collection; otherwise, .
///
public bool Contains(ZipFileSet item) {
return base.List.Contains(item);
}
///
/// Copies the entire collection to a compatible one-dimensional array, starting at the specified index of the target array.
///
/// The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.
/// The zero-based index in at which copying begins.
public void CopyTo(ZipFileSet[] array, int index) {
base.List.CopyTo(array, index);
}
///
/// Retrieves the index of a specified object in the collection.
///
/// The object for which the index is returned.
///
/// The index of the specified . If the is not currently a member of the collection, it returns -1.
///
public int IndexOf(ZipFileSet item) {
return base.List.IndexOf(item);
}
///
/// Inserts a into the collection at the specified index.
///
/// The zero-based index at which should be inserted.
/// The to insert.
public void Insert(int index, ZipFileSet item) {
base.List.Insert(index, item);
}
///
/// Returns an enumerator that can iterate through the collection.
///
///
/// A for the entire collection.
///
public new ZipFileSetEnumerator GetEnumerator() {
return new ZipFileSetEnumerator(this);
}
///
/// Removes a member from the collection.
///
/// The to remove from the collection.
public void Remove(ZipFileSet item) {
base.List.Remove(item);
}
#endregion Public Instance Methods
}
///
/// Enumerates the elements of a .
///
public class ZipFileSetEnumerator : IEnumerator {
#region Internal Instance Constructors
///
/// Initializes a new instance of the class
/// with the specified .
///
/// The collection that should be enumerated.
internal ZipFileSetEnumerator(ZipFileSetCollection ZipFileSets) {
IEnumerable temp = (IEnumerable) (ZipFileSets);
_baseEnumerator = temp.GetEnumerator();
}
#endregion Internal Instance Constructors
#region Implementation of IEnumerator
///
/// Gets the current element in the collection.
///
///
/// The current element in the collection.
///
public ZipFileSet Current {
get { return (ZipFileSet) _baseEnumerator.Current; }
}
object IEnumerator.Current {
get { return _baseEnumerator.Current; }
}
///
/// Advances the enumerator to the next element of the collection.
///
///
/// if the enumerator was successfully advanced
/// to the next element; if the enumerator has
/// passed the end of the collection.
///
public bool MoveNext() {
return _baseEnumerator.MoveNext();
}
bool IEnumerator.MoveNext() {
return _baseEnumerator.MoveNext();
}
///
/// Sets the enumerator to its initial position, which is before the
/// first element in the collection.
///
public void Reset() {
_baseEnumerator.Reset();
}
void IEnumerator.Reset() {
_baseEnumerator.Reset();
}
#endregion Implementation of IEnumerator
#region Private Instance Fields
private IEnumerator _baseEnumerator;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.Compression/Types/ZipFileSet.cs 0000644 0001750 0001750 00000004063 11757302272 022432 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2003 Scott Hernandez
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.Compression.Tasks;
namespace NAnt.Compression.Types {
///
/// A is a with extra
/// attributes useful in the context of the .
///
[ElementName("zipfileset")]
public class ZipFileSet : FileSet {
#region Private Instance Fields
private string _prefix;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// The top level directory prefix. If set, all file and directory paths
/// in the fileset will have this value prepended. Can either be a single
/// directory name or a "/" separated path.
///
[TaskAttribute("prefix", Required=false)]
public string Prefix {
get { return _prefix; }
set {
_prefix = StringUtils.ConvertEmptyToNull(value);
if (_prefix != null && !_prefix.EndsWith("/") && !_prefix.EndsWith("\\")) {
_prefix += "/";
}
}
}
#endregion Public Instance Properties
}
}
nant-0.92-rc1/src/NAnt.Compression/Types/TarFileSet.cs 0000644 0001750 0001750 00000010547 11757302272 022422 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2003 Scott Hernandez
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.Compression.Tasks;
namespace NAnt.Compression.Types {
///
/// A is a with extra
/// attributes useful in the context of the .
///
[ElementName("tarfileset")]
public class TarFileSet : FileSet {
#region Private Instance Fields
private int _fileMode = _fileFlag | 420; // = 644 octal
private int _dirMode = _dirFlag | 493; // = 755 octal
private string _userName;
private int _uid;
private string _groupName;
private int _gid;
private string _prefix;
#endregion Private Instance Fields
#region Private Static Fields
private const int _dirFlag = 16384; // = 40000 octal
private const int _fileFlag = 32768; // = 100000 octal
#endregion Private Static Fields
#region Public Instance Properties
///
/// A 3 digit octal string, specify the user, group and other modes
/// in the standard Unix fashion. Only applies to plain files. The
/// default is 644.
///
[TaskAttribute("filemode")]
public int FileMode {
get { return _fileMode; }
set { _fileMode = _fileFlag | Convert.ToInt32(Convert.ToString(value), 8); }
}
///
/// A 3 digit octal string, specify the user, group and other modes
/// in the standard Unix fashion. Only applies to directories. The
/// default is 755.
///
[TaskAttribute("dirmode")]
public int DirMode {
get { return _dirMode; }
set { _dirMode = _dirFlag | Convert.ToInt32(Convert.ToString(value), 8); }
}
///
/// The username for the tar entry.
///
[TaskAttribute("username")]
public string UserName {
get { return _userName; }
set { _userName = StringUtils.ConvertEmptyToNull(value); }
}
///
/// The user identifier (UID) for the tar entry.
///
[TaskAttribute("uid")]
public int Uid {
get { return _uid; }
set { _uid = value; }
}
///
/// The groupname for the tar entry.
///
[TaskAttribute("groupname")]
public string GroupName {
get { return _groupName; }
set { _groupName = StringUtils.ConvertEmptyToNull(value); }
}
///
/// The group identifier (GID) for the tar entry.
///
[TaskAttribute("gid")]
public int Gid {
get { return _gid; }
set { _gid = value; }
}
///
/// The top level directory prefix. If set, all file and directory paths
/// in the fileset will have this value prepended. Can either be a single
/// directory name or a "/" separated path.
///
[TaskAttribute("prefix")]
public string Prefix {
get { return _prefix; }
set {
_prefix = StringUtils.ConvertEmptyToNull(value);
if (_prefix != null && !_prefix.EndsWith("/") && !_prefix.EndsWith("\\")) {
_prefix += "/";
}
}
}
#endregion Public Instance Properties
}
}
nant-0.92-rc1/src/NAnt.Compression/Tasks/ 0000755 0001750 0001750 00000000000 11757310030 020032 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.Compression/Tasks/ExpandBaseTask.cs 0000644 0001750 0001750 00000013604 11757302272 023233 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2009 Gert Driesen
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
using System;
using System.Globalization;
using System.IO;
using NAnt.Core;
using NAnt.Core.Attributes;
namespace NAnt.Compression.Tasks {
///
/// Summary description for ExpandTask.
///
public abstract class ExpandBaseTask : Task {
private bool _overwrite = true;
///
/// Overwrite files, even if they are newer than the corresponding
/// entries in the archive. The default is .
///
[TaskAttribute("overwrite", Required=false)]
public virtual bool Overwrite {
get { return _overwrite; }
set { _overwrite = value; }
}
///
/// Extracts a file entry from the specified stream.
///
/// The containing the compressed entry.
/// The directory where to store the expanded file.
/// The name of the entry including directory information.
/// The date of the entry.
/// The uncompressed size of the entry.
///
/// The destination directory for the entry could not be created.
/// -or-
/// The entry could not be extracted.
///
///
/// We cannot rely on the fact that the directory entry of a given file
/// is created before the file is extracted, so we should create the
/// directory if it doesn't yet exist.
///
protected void ExtractFile(Stream inputStream, string destDirectory, string entryName, DateTime entryDate, long entrySize) {
// determine destination file
FileInfo destFile = new FileInfo(Path.Combine(destDirectory,
entryName));
// ensure destination directory exists
if (!destFile.Directory.Exists) {
try {
destFile.Directory.Create();
destFile.Directory.LastWriteTime = entryDate;
destFile.Directory.Refresh();
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Directory '{0}' could not be created.", destFile.DirectoryName),
Location, ex);
}
}
// determine if entry actually needs to be extracted
if (!Overwrite && destFile.Exists && destFile.LastWriteTime >= entryDate) {
Log(Level.Debug, "Skipping '{0}' as it is up-to-date.",
destFile.FullName);
return;
}
Log(Level.Verbose, "Extracting '{0}' to '{1}'.", entryName,
destDirectory);
try {
// extract the entry
using (FileStream sw = new FileStream(destFile.FullName, FileMode.Create, FileAccess.Write)) {
int size = 2048;
byte[] data = new byte[2048];
while (true) {
size = inputStream.Read(data, 0, data.Length);
if (size == 0) {
break;
}
sw.Write(data, 0, size);
}
sw.Close();
}
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Unable to expand '{0}' to '{1}'.", entryName, destDirectory),
Location, ex);
}
destFile.LastWriteTime = entryDate;
}
///
/// Extracts a directory entry from the specified stream.
///
/// The containing the directory entry.
/// The directory where to create the subdirectory.
/// The name of the directory entry.
/// The date of the entry.
///
/// The destination directory for the entry could not be created.
///
protected void ExtractDirectory(Stream inputStream, string destDirectory, string entryName, DateTime entryDate) {
DirectoryInfo destDir = new DirectoryInfo(Path.Combine(
destDirectory, entryName));
if (!destDir.Exists) {
try {
destDir.Create();
destDir.LastWriteTime = entryDate;
destDir.Refresh();
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Directory '{0}' could not be created.", destDir.FullName),
Location, ex);
}
}
}
}
}
nant-0.92-rc1/src/NAnt.Compression/Tasks/UnTarTask.cs 0000644 0001750 0001750 00000014200 11757302272 022243 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2009 Gert Driesen
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
using System;
using System.Globalization;
using System.IO;
using System.Text;
using ICSharpCode.SharpZipLib;
using ICSharpCode.SharpZipLib.BZip2;
using ICSharpCode.SharpZipLib.GZip;
using ICSharpCode.SharpZipLib.Tar;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Util;
using NAnt.Compression.Types;
namespace NAnt.Compression.Tasks {
///
/// Extracts files from a tar archive.
///
///
///
/// Uses #ziplib
/// (SharpZipLib), an open source Zip/GZip library written entirely in C#.
///
///
///
/// Extracts all files from a gzipped tar, preserving the directory structure.
///
///
/// ]]>
///
///
[TaskName("untar")]
public class UnTarTask : ExpandBaseTask {
#region Private Instance Fields
private FileInfo _srcFile;
private DirectoryInfo _destDir;
private TarCompressionMethod _compressionMethod = TarCompressionMethod.None;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// The archive file to expand.
///
[TaskAttribute("src", Required=true)]
public FileInfo SrcFile {
get { return _srcFile; }
set { _srcFile = value; }
}
///
/// The directory where to store the expanded file(s). The default is
/// the project base directory.
///
[TaskAttribute("dest", Required=false)]
public DirectoryInfo DestinationDirectory {
get {
if (_destDir == null)
_destDir = new DirectoryInfo(Project.BaseDirectory);
return _destDir;
}
set { _destDir = value; }
}
///
/// The compression method. The default is .
///
[TaskAttribute("compression")]
public TarCompressionMethod CompressionMethod {
get { return _compressionMethod; }
set { _compressionMethod = value; }
}
#endregion Public Instance Properties
#region Override implementation of Task
///
/// Extracts the files from the archive.
///
protected override void ExecuteTask() {
Stream fs = null;
Stream instream = null;
try {
// ensure archive exists
if (!SrcFile.Exists)
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Tar file '{0}' does not exist.", SrcFile.FullName),
Location);
fs = SrcFile.OpenRead();
// wrap inputstream with corresponding compression method
switch (CompressionMethod) {
case TarCompressionMethod.GZip:
instream = new GZipInputStream(fs);
break;
case TarCompressionMethod.BZip2:
instream = new BZip2InputStream(fs);
break;
default:
instream = fs;
break;
}
using (TarInputStream s = new TarInputStream(instream)) {
Log(Level.Info, "Expanding '{0}' to '{1}'.",
SrcFile.FullName, DestinationDirectory.FullName);
TarEntry entry;
// extract the file or directory entry
while ((entry = s.GetNextEntry()) != null) {
if (entry.IsDirectory) {
ExtractDirectory(s, DestinationDirectory.FullName,
entry.Name, entry.ModTime);
} else {
ExtractFile(s, DestinationDirectory.FullName,
entry.Name, entry.ModTime, entry.Size);
}
}
}
} catch (IOException ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Failed to expand '{0}' to '{1}'.", SrcFile.FullName,
DestinationDirectory.FullName), Location, ex);
} catch (TarException ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Invalid tar file '{0}'.", SrcFile.FullName), Location, ex);
} catch (BZip2Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Invalid bzip2'd tar file '{0}'.", SrcFile.FullName), Location, ex);
} catch (GZipException ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Invalid gzipped tar file '{0}'.", SrcFile.FullName), Location, ex);
} finally {
// close the filestream
if (fs != null)
fs.Close ();
}
}
#endregion Override implementation of Task
}
}
nant-0.92-rc1/src/NAnt.Compression/Tasks/UnZipTask.cs 0000644 0001750 0001750 00000012325 11757302272 022265 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2003 Scott Hernandez
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Scott Hernandez (ScottHernandez@hotmail.com)
using System;
using System.Globalization;
using System.IO;
using System.Text;
using ICSharpCode.SharpZipLib;
using ICSharpCode.SharpZipLib.Zip;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Util;
namespace NAnt.Compression.Tasks {
///
/// Extracts files from a zip archive.
///
///
///
/// Uses #ziplib
/// (SharpZipLib), an open source Zip/GZip library written entirely in C#.
///
///
///
/// Extracts all the file from the zip, preserving the directory structure.
///
///
/// ]]>
///
///
[TaskName("unzip")]
public class UnZipTask : ExpandBaseTask {
#region Private Instance Fields
private FileInfo _zipfile;
private DirectoryInfo _toDir;
private Encoding _encoding;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// The archive file to expand.
///
[TaskAttribute("zipfile", Required=true)]
public FileInfo ZipFile {
get { return _zipfile; }
set { _zipfile = value; }
}
///
/// The directory where the expanded files should be stored. The
/// default is the project base directory.
///
[TaskAttribute("todir", Required=false)]
public DirectoryInfo ToDirectory {
get {
if (_toDir == null)
_toDir = new DirectoryInfo(Project.BaseDirectory);
return _toDir;
}
set { _toDir = value; }
}
///
/// The character encoding that has been used for filenames inside the
/// zip file. The default is the system's OEM code page.
///
[TaskAttribute("encoding")]
public Encoding Encoding {
get {
if (_encoding == null) {
_encoding = Encoding.GetEncoding(CultureInfo.CurrentCulture.TextInfo.OEMCodePage);
}
return _encoding;
}
set { _encoding = value; }
}
#endregion Public Instance Properties
#region Override implementation of Task
///
/// Extracts the files from the zip file.
///
protected override void ExecuteTask() {
try {
// ensure zip file exists
if (!ZipFile.Exists) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Zip file '{0}' does not exist.", ZipFile.FullName),
Location);
}
// set encoding of filenames and comment
ZipConstants.DefaultCodePage = Encoding.CodePage;
using (ZipInputStream s = new ZipInputStream(ZipFile.OpenRead())) {
Log(Level.Info, "Unzipping '{0}' to '{1}'.",
ZipFile.FullName, ToDirectory.FullName);
ZipEntry entry;
// extract the file or directory entry
while ((entry = s.GetNextEntry()) != null) {
if (entry.IsDirectory) {
ExtractDirectory(s, ToDirectory.FullName,
entry.Name, entry.DateTime);
} else {
ExtractFile(s, ToDirectory.FullName, entry.Name,
entry.DateTime, entry.Size);
}
}
// close the zip stream
s.Close();
}
} catch (IOException ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Failed to expand '{0}' to '{1}'.", ZipFile.FullName,
ToDirectory.FullName), Location, ex);
} catch (ZipException ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Invalid zip file '{0}'.", ZipFile.FullName), Location, ex);
}
}
#endregion Override implementation of Task
}
}
nant-0.92-rc1/src/NAnt.Compression/Tasks/GUnzip.cs 0000644 0001750 0001750 00000007671 11757302272 021621 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System.Globalization;
using System.IO;
using ICSharpCode.SharpZipLib.GZip;
using NAnt.Core;
using NAnt.Core.Attributes;
namespace NAnt.Compression.Tasks {
///
/// Expands a file packed using GZip compression.
///
///
/// Expands "test.tar.gz" to "test2.tar".
///
///
/// ]]>
///
///
[TaskName("gunzip")]
public class GUnzip : Task {
#region Private Instance Fields
private FileInfo _srcFile;
private FileInfo _destFile;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// The file to expand.
///
[TaskAttribute("src", Required=true)]
public FileInfo SrcFile {
get { return _srcFile; }
set { _srcFile = value; }
}
///
/// The destination file.
///
[TaskAttribute("dest", Required=true)]
public FileInfo DestFile {
get { return _destFile; }
set { _destFile = value; }
}
#endregion Public Instance Properties
#region Override implementation of Task
///
/// Extracts the file from the gzip archive.
///
protected override void ExecuteTask() {
try {
using (GZipInputStream gzs = new GZipInputStream(SrcFile.OpenRead())) {
Log(Level.Info, "Expanding '{0}' to '{1}' ({2} bytes).",
SrcFile.FullName, DestFile.FullName, gzs.Length);
// holds data from src file
byte[] data = new byte[8 * 1024];
// first read from input to ensure we're dealing with valid
// src file before we actually create the dest file
int size = gzs.Read(data, 0, data.Length);
// write expanded data to dest file
using (FileStream fs = new FileStream(DestFile.FullName, FileMode.Create, FileAccess.Write, FileShare.None)) {
while (size > 0) {
fs.Write(data, 0, size);
size = gzs.Read(data, 0, data.Length);
}
// close output stream
fs.Close();
}
// close input stream
gzs.Close();
}
} catch (IOException ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Failed to expand '{0}' to '{1}'.", SrcFile.FullName,
DestFile.FullName), Location, ex);
} catch (GZipException ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Invalid gzip file '{0}'.", SrcFile.FullName), Location, ex);
}
}
#endregion Override implementation of Task
}
}
nant-0.92-rc1/src/NAnt.Compression/Tasks/ZipTask.cs 0000644 0001750 0001750 00000035367 11757302272 021775 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Mike Krueger (mike@icsharpcode.net)
// Gerry Shaw (gerry_shaw@yahoo.com)
using System;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Text;
using ICSharpCode.SharpZipLib.Checksums;
using ICSharpCode.SharpZipLib.Zip;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.Compression.Types;
namespace NAnt.Compression.Tasks {
///
/// Creates a zip file from the specified filesets.
///
///
///
/// Uses #ziplib
/// (SharpZipLib), an open source Tar/Zip/GZip library written entirely in C#.
///
///
///
///
/// Zip all files in ${build.dir} and ${doc.dir} into a file
/// called "backup.zip".
///
///
///
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("zip")]
public class ZipTask : Task {
#region Private Instance Fields
private FileInfo _zipfile;
private int _ziplevel = 6;
private ZipFileSetCollection _filesets = new ZipFileSetCollection();
private DateTime _stampDateTime;
private string _comment;
private bool _includeEmptyDirs;
private bool _flatten;
private DuplicateHandling _duplicateHandling = DuplicateHandling.Add;
private Encoding _encoding;
private Hashtable _addedDirs = new Hashtable();
private Hashtable _fileEntries = new Hashtable();
#endregion Private Instance Fields
#region Public Instance Properties
///
/// The zip file to create.
///
[TaskAttribute("zipfile", Required=true)]
public FileInfo ZipFile {
get { return _zipfile; }
set { _zipfile = value; }
}
///
/// The comment for the file.
///
[TaskAttribute("comment")]
public string Comment {
get { return _comment; }
set { _comment = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Date/time stamp for the files in the format MM/DD/YYYY HH:MM:SS.
///
[TaskAttribute("stampdatetime")]
[DateTimeValidator()]
public DateTime Stamp {
get { return _stampDateTime; }
set { _stampDateTime = value; }
}
///
/// Desired level of compression. Possible values are 0 (STORE only)
/// to 9 (highest). The default is 6.
///
[TaskAttribute("ziplevel")]
[Int32ValidatorAttribute(0, 9)]
public int ZipLevel {
get { return _ziplevel; }
set { _ziplevel = value; }
}
///
/// Include empty directories in the generated zip file. The default is
/// .
///
[TaskAttribute("includeemptydirs")]
[BooleanValidator()]
public bool IncludeEmptyDirs {
get { return _includeEmptyDirs; }
set { _includeEmptyDirs = value; }
}
///
/// Ignore directory structure of source directory, compress all files
/// into a single directory.
/// The default value is .
///
[TaskAttribute("flatten")]
[BooleanValidator()]
public virtual bool Flatten {
get { return _flatten; }
set { _flatten = value; }
}
///
/// The set of files to be included in the archive.
///
[BuildElementArray("fileset")]
public ZipFileSetCollection ZipFileSets {
get { return _filesets; }
set { _filesets = value; }
}
///
/// Specifies the behaviour when a duplicate file is found. The default
/// is .
///
[TaskAttribute("duplicate")]
public DuplicateHandling DuplicateHandling {
get { return _duplicateHandling; }
set { _duplicateHandling = value; }
}
///
/// The character encoding to use for filenames and comment inside the
/// zip file. The default is the system's OEM code page.
///
[TaskAttribute("encoding")]
public Encoding Encoding {
get {
if (_encoding == null) {
_encoding = Encoding.GetEncoding(CultureInfo.CurrentCulture.TextInfo.OEMCodePage);
}
return _encoding;
}
set { _encoding = value; }
}
#endregion Public Instance Properties
#region Override implementation of Task
///
/// Creates the zip file.
///
protected override void ExecuteTask() {
ZipOutputStream zOutstream = null;
Log(Level.Info, "Zipping {0} files to '{1}'.",
ZipFileSets.FileCount, ZipFile.FullName);
try {
if (!Directory.Exists(ZipFile.DirectoryName)) {
Directory.CreateDirectory(ZipFile.DirectoryName);
}
// set encoding to use for filenames and comment
ZipConstants.DefaultCodePage = Encoding.CodePage;
zOutstream = new ZipOutputStream(ZipFile.Create());
// set compression level
zOutstream.SetLevel(ZipLevel);
// set comment
if (!String.IsNullOrEmpty(Comment)) {
zOutstream.SetComment(Comment);
}
foreach (ZipFileSet fileset in ZipFileSets) {
string basePath = fileset.BaseDirectory.FullName;
if (Path.GetPathRoot(basePath) != basePath) {
basePath = Path.GetDirectoryName(basePath + Path.DirectorySeparatorChar);
}
// add files to zip
foreach (string file in fileset.FileNames) {
// ensure file exists (in case "asis" was used)
if (!File.Exists(file)) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"File '{0}' does not exist.", file), Location);
}
// the name of the zip entry
string entryName;
// determine name of the zip entry
if (!Flatten && file.StartsWith(basePath)) {
entryName = file.Substring(basePath.Length);
if (entryName.Length > 0 && entryName[0] == Path.DirectorySeparatorChar) {
entryName = entryName.Substring(1);
}
// remember that directory was added to zip file, so
// that we won't add it again later
string dir = Path.GetDirectoryName(file);
if (_addedDirs[dir] == null) {
_addedDirs[dir] = dir;
}
} else {
// flatten directory structure
entryName = Path.GetFileName(file);
}
// add prefix if specified
if (fileset.Prefix != null) {
entryName = fileset.Prefix + entryName;
}
// ensure directory separators are understood on linux
if (Path.DirectorySeparatorChar == '\\') {
entryName = entryName.Replace(@"\", "/");
}
// perform duplicate checking
if (_fileEntries.ContainsKey(entryName)) {
switch (DuplicateHandling) {
case DuplicateHandling.Add:
break;
case DuplicateHandling.Fail:
throw new BuildException(string.Format(
CultureInfo.InvariantCulture,
"Duplicate file '{0}' was found.",
entryName), Location.UnknownLocation);
case DuplicateHandling.Preserve:
// skip current entry
continue;
default:
throw new BuildException(string.Format(
CultureInfo.InvariantCulture,
"Duplicate value '{0}' is not supported.",
DuplicateHandling.ToString()),
Location.UnknownLocation);
}
}
// create zip entry
ZipEntry entry = new ZipEntry(entryName);
// store entry (to allow for duplicate checking)
_fileEntries[entryName] = null;
// set date/time stamp on zip entry
if (Stamp != DateTime.MinValue) {
entry.DateTime = Stamp;
} else {
entry.DateTime = File.GetLastWriteTime(file);
}
// write file content to stream in small chuncks
using (FileStream fs = File.OpenRead(file)) {
// set size for backward compatibility with older unzip
entry.Size = fs.Length;
Log(Level.Verbose, "Adding {0}.", entryName);
// write file to zip file
zOutstream.PutNextEntry(entry);
byte[] buffer = new byte[50000];
while (true) {
int bytesRead = fs.Read(buffer, 0, buffer.Length);
if (bytesRead == 0)
break;
zOutstream.Write(buffer, 0, bytesRead);
}
}
}
// add (possibly empty) directories to zip
if (IncludeEmptyDirs) {
foreach (string directory in fileset.DirectoryNames) {
// skip directories that were already added when the
// files were added
if (_addedDirs[directory] != null) {
continue;
}
// skip directories that are not located beneath the base
// directory
if (!directory.StartsWith(basePath) || directory.Length <= basePath.Length) {
continue;
}
// determine zip entry name
string entryName = directory.Substring(basePath.Length + 1);
// add prefix if specified
if (fileset.Prefix != null) {
entryName = fileset.Prefix + entryName;
}
// ensure directory separators are understood on linux
if (Path.DirectorySeparatorChar == '\\') {
entryName = entryName.Replace(@"\", "/");
}
if (!entryName.EndsWith("/")) {
// trailing directory signals to #ziplib that we're
// dealing with directory entry
entryName += "/";
}
// create directory entry
ZipEntry entry = new ZipEntry(entryName);
// set size for backward compatibility with older unzip
entry.Size = 0L;
// write directory to zip file
zOutstream.PutNextEntry(entry);
}
}
}
zOutstream.Close();
zOutstream.Finish();
} catch (Exception ex) {
// close the zip output stream
if (zOutstream != null) {
zOutstream.Close();
}
// delete the (possibly corrupt) zip file
if (ZipFile.Exists) {
ZipFile.Delete();
}
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Zip file '{0}' could not be created.", ZipFile.FullName),
Location, ex);
} finally {
CleanUp();
}
}
#endregion Override implementation of Task
#region Private Instance Methods
private void CleanUp() {
_addedDirs.Clear();
_fileEntries.Clear();
}
#endregion Private Instance Methods
}
}
nant-0.92-rc1/src/NAnt.Compression/Tasks/TarTask.cs 0000644 0001750 0001750 00000030302 11757302272 021741 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
using System.Globalization;
using System.IO;
using ICSharpCode.SharpZipLib.BZip2;
using ICSharpCode.SharpZipLib.Checksums;
using ICSharpCode.SharpZipLib.GZip;
using ICSharpCode.SharpZipLib.Tar;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.Compression.Types;
namespace NAnt.Compression.Tasks {
///
/// Creates a tar file from the specified filesets.
///
///
/// Uses #ziplib (SharpZipLib), an open source Tar/Zip/GZip library written entirely in C#.
///
///
///
/// Tar all files in ${build.dir} and ${doc.dir} into a file
/// called "backup.tar.gz", and apply gzip compression to it.
///
///
///
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("tar")]
public class TarTask : Task {
#region Private Instance Fields
private FileInfo _destFile;
private TarFileSetCollection _filesets = new TarFileSetCollection();
private bool _flatten = false;
private bool _includeEmptyDirs = false;
private TarCompressionMethod _compressionMethod = TarCompressionMethod.None;
private Hashtable _addedDirs = new Hashtable();
#endregion Private Instance Fields
#region Public Instance Properties
///
/// The tar file to create.
///
[TaskAttribute("destfile", Required=true)]
public FileInfo DestFile {
get { return _destFile; }
set { _destFile = value; }
}
///
/// Include empty directories in the generated tar file. The default is
/// .
///
[TaskAttribute("includeemptydirs", Required=false)]
[BooleanValidator()]
public bool IncludeEmptyDirs {
get { return _includeEmptyDirs; }
set { _includeEmptyDirs = value; }
}
///
/// Ignore directory structure of source directory, compress all files
/// into a single directory.
/// The default value is .
///
[TaskAttribute("flatten")]
[BooleanValidator()]
public virtual bool Flatten {
get { return _flatten; }
set { _flatten = value; }
}
///
/// The set of files to be included in the archive.
///
[BuildElementArray("fileset")]
public TarFileSetCollection TarFileSets {
get { return _filesets; }
}
///
/// The compression method. The default is .
///
[TaskAttribute("compression")]
public TarCompressionMethod CompressionMethod {
get { return _compressionMethod; }
set { _compressionMethod = value; }
}
#endregion Public Instance Properties
#region Override implementation of Task
///
/// Creates the tar file.
///
protected override void ExecuteTask() {
TarArchive archive = null;
Stream outstream = null;
Log(Level.Info, "Tarring {0} files to '{1}'.",
TarFileSets.FileCount, DestFile.FullName);
try {
if (!Directory.Exists(DestFile.DirectoryName)) {
Directory.CreateDirectory(DestFile.DirectoryName);
}
outstream = File.Create(DestFile.FullName);
// wrap outputstream with corresponding compression method
switch (CompressionMethod) {
case TarCompressionMethod.GZip:
outstream = new GZipOutputStream(outstream);
break;
case TarCompressionMethod.BZip2:
outstream = new BZip2OutputStream(outstream);
break;
}
// create tar archive
archive = TarArchive.CreateOutputTarArchive(outstream,
TarBuffer.DefaultBlockFactor);
// do not use convert line endings of text files to \n, as this
// converts all content to ASCII
archive.AsciiTranslate = false;
// process all filesets
foreach (TarFileSet fileset in TarFileSets) {
string basePath = fileset.BaseDirectory.FullName;
if (Path.GetPathRoot(basePath) != basePath) {
basePath = Path.GetDirectoryName(basePath + Path.DirectorySeparatorChar);
}
// add files to tar
foreach (string file in fileset.FileNames) {
// ensure file exists (in case "asis" was used)
if (!File.Exists(file)) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"File '{0}' does not exist.", file), Location);
}
// the filename of the tar entry
string entryFileName;
// the directory of the tar entry
string entryDirName = string.Empty;
// determine name of the tar entry
if (!Flatten && file.StartsWith(basePath)) {
entryFileName = file.Substring(basePath.Length);
if (entryFileName.Length > 0 && entryFileName[0] == Path.DirectorySeparatorChar) {
entryFileName = entryFileName.Substring(1);
}
// get directory part of entry
entryDirName = Path.GetDirectoryName(entryFileName);
// ensure directory separators are understood on linux
if (Path.DirectorySeparatorChar == '\\') {
entryDirName = entryDirName.Replace(@"\", "/");
}
// get filename part of entry
entryFileName = Path.GetFileName(entryFileName);
} else {
entryFileName = Path.GetFileName(file);
}
// add prefix if specified
if (fileset.Prefix != null) {
entryDirName = fileset.Prefix + entryDirName;
}
// ensure directory has trailing slash
if (entryDirName.Length != 0) {
if (!entryDirName.EndsWith("/")) {
entryDirName += '/';
}
// create directory entry in archive
CreateDirectoryEntry(archive, entryDirName, fileset);
}
TarEntry entry = TarEntry.CreateEntryFromFile(file);
entry.Name = entryDirName + entryFileName;
entry.GroupId = fileset.Gid;
entry.GroupName = fileset.GroupName;
entry.UserId = fileset.Uid;
entry.UserName = fileset.UserName;
entry.TarHeader.Mode = fileset.FileMode;
// write file to tar file
archive.WriteEntry(entry, true);
}
// add (possibly empty) directories to zip
if (IncludeEmptyDirs) {
// add (possibly empty) directories to tar
foreach (string directory in fileset.DirectoryNames) {
// skip directories that are not located beneath the base
// directory
if (!directory.StartsWith(basePath) || directory.Length <= basePath.Length) {
continue;
}
// determine tar entry name
string entryName = directory.Substring(basePath.Length + 1);
// add prefix if specified
if (fileset.Prefix != null) {
entryName = fileset.Prefix + entryName;
}
// ensure directory separators are understood on linux
if (Path.DirectorySeparatorChar == '\\') {
entryName = entryName.Replace(@"\", "/");
}
if (!entryName.EndsWith("/")) {
// trailing directory signals to #ziplib that we're
// dealing with directory entry
entryName += "/";
}
// create directory entry in archive
CreateDirectoryEntry(archive, entryName, fileset);
}
}
}
// close the tar archive
archive.Close();
} catch (Exception ex) {
// close the tar output stream
if (outstream != null) {
outstream.Close();
}
// close the tar archive
if (archive != null) {
archive.Close();
}
// delete the (possibly corrupt) tar file
if (DestFile.Exists) {
DestFile.Delete();
}
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Tar file '{0}' could not be created.", DestFile.FullName),
Location, ex);
}
}
#endregion Override implementation of Task
#region Private Instance Methods
private void CreateDirectoryEntry(TarArchive archive, string entryName, TarFileSet fileset) {
// skip directories that were already added before
if (_addedDirs.ContainsKey(entryName)) {
return;
}
// create directory entry
TarEntry entry = TarEntry.CreateTarEntry(entryName);
entry.GroupId = fileset.Gid;
entry.GroupName = fileset.GroupName;
entry.UserId = fileset.Uid;
entry.UserName = fileset.UserName;
entry.TarHeader.Mode = fileset.DirMode;
// write directory to tar file
archive.WriteEntry(entry, false);
// remember that directory entry was added
_addedDirs[entryName] = null;
}
#endregion Private Instance Methods
}
}
nant-0.92-rc1/src/NAnt.Compression/NAnt.Compression.build 0000644 0001750 0001750 00000002440 11757302272 023137 0 ustar jtaylor jtaylor
nant-0.92-rc1/src/NAnt.Compression/NAnt.Compression.csproj 0000644 0001750 0001750 00000011215 11757302272 023340 0 ustar jtaylor jtaylor
DebugAnyCPU2.0{8F80C098-94A4-44DB-A25D-C9E455FC3120}NAnt.CompressionNAnt.CompressionTasksLibraryOnSuccessfulBuildfalse8.0.50727v2.02.0publish\trueDiskfalseForeground7Daysfalsefalsetrue01.0.0.%2afalsefalsetruetruefullfalse..\..\build\Debug\4AllRules.rulesetTRACE;DEBUG..\..\build\Debug\NAnt.CompressionTasks.xmltruepdbonlytrue..\..\build\Release\4AllRules.rulesetTRACE..\..\build\Release\NAnt.CompressionTasks.xml..\..\lib\common\neutral\ICSharpCode.SharpZipLib.dll
CommonAssemblyInfo.cs
False.NET Framework 3.5 SP1 Client ProfilefalseFalse.NET Framework 3.5 SP1trueFalseWindows Installer 3.1true{8F5F8375-4097-4952-B860-784EB9961ABE}NAnt.Core nant-0.92-rc1/src/NAnt.Win32/ 0000755 0001750 0001750 00000000000 11757310030 015346 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.Win32/NAnt.Win32.build 0000644 0001750 0001750 00000002527 11757302274 020151 0 ustar jtaylor jtaylor
nant-0.92-rc1/src/NAnt.Win32/AssemblyInfo.cs 0000644 0001750 0001750 00000002557 11757302274 020314 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Scott Hernandez (ScottHernandez@hotmail.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System.Reflection;
using System.Security.Permissions;
// This will not compile with Visual Studio. If you want to build a signed
// executable use the NAnt build file. To build under Visual Studio just
// exclude this file from the build.
[assembly: AssemblyDelaySign(false)]
//[assembly: AssemblyKeyFile(@"..\NAnt.key")]
[assembly: AssemblyKeyName("")]
#if (!NET_4_0)
[assembly: RegistryPermissionAttribute(SecurityAction.RequestMinimum , Unrestricted=true)]
#endif nant-0.92-rc1/src/NAnt.Win32/NAnt.Win32.csproj 0000644 0001750 0001750 00000010776 11757302274 020357 0 ustar jtaylor jtaylor
DebugAnyCPU2.0{C66545A2-6FEC-4A38-937A-5B25E61EE8A1}NAnt.Win32NAnt.Win32TasksLibraryOnSuccessfulBuildfalse8.0.50727v2.02.0publish\trueDiskfalseForeground7Daysfalsefalsetrue01.0.0.%2afalsefalsetruetruefullfalse4..\..\build\Debug\AllRules.rulesetTRACE;DEBUG..\..\build\Debug\NAnt.Win32Tasks.xmltruepdbonlytrue..\..\build\Release\4AllRules.rulesetTRACE..\..\build\Release\NAnt.Win32Tasks.xml
CommonAssemblyInfo.cs
False.NET Framework 3.5 SP1 Client ProfilefalseFalse.NET Framework 3.5 SP1trueFalseWindows Installer 3.1true{8F5F8375-4097-4952-B860-784EB9961ABE}NAnt.Core{B50A1067-785B-4686-8FFC-5AF424BEF163}NAnt.DotNet nant-0.92-rc1/src/NAnt.Win32/Functions/ 0000755 0001750 0001750 00000000000 11757310030 017316 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.Win32/Functions/CygpathFunctions.cs 0000644 0001750 0001750 00000014305 11757302274 023153 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Ian Maclean (imaclean@gmail.com)
// Jaroslaw Kowalski (jkowalski@users.sourceforge.net)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.ComponentModel;
using System.IO;
using System.Collections;
using System.Reflection;
using System.Globalization;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
namespace NAnt.Win32.Functions {
///
/// Groups a set of functions that convert Windows native filenames to
/// Cygwin POSIX-style pathnames and vice versa.
///
///
/// It can be used when a Cygwin program needs to pass a file name to a
/// native Windows program, or expects to get a file name from a native
/// Windows program.
///
[FunctionSet("cygpath", "Unix/Cygwin")]
public class CygpathFunctions : FunctionSetBase {
#region Public Instance Constructors
///
/// Initializes a new instance of the
/// class with the specified and properties.
///
/// The in which the class is used.
/// The set of properties to use for macro expansion.
public CygpathFunctions(Project project, PropertyDictionary properties) : base(project, properties) {
}
#endregion Public Instance Constructors
#region Public Instance Methods
///
/// Gets the DOS (short) form of the specified path.
///
/// The path to convert.
///
/// The DOS (short) form of the specified path.
///
/// cygpath could not be started.
/// could not be converted to a short form.
[Function("get-dos-path")]
public string GetDosPath(string path) {
return RunCygpathString(new Argument[] {
new Argument("--dos \"" + path + "\"") });
}
///
/// Gets the Unix form of the specified path.
///
/// The path to convert.
///
/// The Unix form of the specified path.
///
/// cygpath could not be started.
/// could not be converted to a Unix form.
[Function("get-unix-path")]
public string GetUnixPath(string path) {
return RunCygpathString(new Argument[] {
new Argument("--unix \"" + path + "\"") });
}
///
/// Gets the Windows form of the specified path.
///
/// The path to convert.
///
/// The Windows form of the specified path.
///
/// cygpath could not be started.
/// could not be converted to a Windows form.
[Function("get-windows-path")]
public string GetWindowsPath(string path) {
return RunCygpathString(new Argument[] {
new Argument("--windows \"" + path + "\"") });
}
#endregion Public Instance Methods
#region Private Instance Methods
///
/// Runs cygpath with the specified arguments and returns the result
/// as a .
///
/// The arguments to pass to cygpath.
///
/// The result of running cygpath with the specified arguments.
///
private string RunCygpathString(Argument[] args) {
MemoryStream ms = new MemoryStream();
ExecTask execTask = GetTask(ms);
execTask.Arguments.AddRange(args);
try {
execTask.Execute();
ms.Position = 0;
StreamReader sr = new StreamReader(ms);
string output = sr.ReadLine();
sr.Close();
return output;
} catch (Exception ex) {
ms.Position = 0;
StreamReader sr = new StreamReader(ms);
string output = sr.ReadToEnd();
sr.Close();
if (output.Length != 0) {
throw new BuildException(output, ex);
} else {
throw;
}
}
}
///
/// Factory method to return a new instance of ExecTask
///
///
///
private ExecTask GetTask(Stream stream) {
ExecTask execTask = new ExecTask();
execTask.Parent = Project;
execTask.Project = Project;
execTask.FileName = "cygpath";
execTask.Threshold = Level.None;
execTask.ErrorWriter = execTask.OutputWriter = new StreamWriter(stream);
return execTask;
}
#endregion Private Instance Methods
}
}
nant-0.92-rc1/src/NAnt.Win32/Tasks/ 0000755 0001750 0001750 00000000000 11757310030 016433 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.Win32/Tasks/RegAsmTask.cs 0000644 0001750 0001750 00000034560 11757302274 021006 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2006 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Ian MacLean (ian@maclean.ms)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Text;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.Core.Tasks;
using NAnt.Core.Util;
using NAnt.DotNet.Types;
namespace NAnt.Win32.Tasks {
///
/// Registers an assembly, or set of assemblies for use from COM clients.
///
///
///
/// Refer to the Regasm
/// documentation for more information on the regasm tool.
///
///
///
///
/// Register types in a single assembly.
///
///
///
/// ]]>
///
///
///
///
/// Register types of an assembly and generate a type library containing
/// definitions of accessible types defined within the assembly.
///
///
///
/// ]]>
///
///
///
///
/// Register types of set of assemblies at once, while specifying a set
/// of reference assemblies.
///
///
///
///
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("regasm")]
[ProgramLocation(LocationType.FrameworkDir)]
public class RegAsmTask : ExternalProgramBase {
#region Private Instance Fields
private StringBuilder _arguments = new StringBuilder();
private string _programFileName;
private DirectoryInfo _workingDirectory;
private FileInfo _assemblyFile;
private FileInfo _regfile;
private FileInfo _typelib;
private bool _codebase;
private bool _unregister;
private bool _registered;
private AssemblyFileSet _assemblies = new AssemblyFileSet();
private AssemblyFileSet _references = new AssemblyFileSet();
#endregion Private Instance Fields
#region Public Instance Properties
///
/// The name of the file to register. This is provided as an alternate
/// to using the task's .
///
[TaskAttribute("assembly")]
public FileInfo AssemblyFile {
get { return _assemblyFile; }
set { _assemblyFile = value; }
}
///
/// Registry file to export to instead of entering the types directly
/// into the registry.
///
[TaskAttribute("regfile")]
public FileInfo RegistryFile {
get { return _regfile; }
set { _regfile = value; }
}
///
/// Set the code base registry setting.
///
[TaskAttribute("codebase")]
[BooleanValidator()]
public bool CodeBase {
get { return _codebase; }
set { _codebase = value; }
}
///
/// Only refer to already registered type libraries.
///
[TaskAttribute("registered")]
[BooleanValidator()]
public bool Registered {
get { return _registered; }
set { _registered = value; }
}
///
/// Export the assemblies to the specified type library and register it.
///
[TaskAttribute("typelib")]
public FileInfo TypeLib {
get { return _typelib; }
set { _typelib = value; }
}
///
/// Unregister the assembly. The default is .
///
[TaskAttribute("unregister")]
[BooleanValidator()]
public bool Unregister {
get { return _unregister; }
set { _unregister = value; }
}
///
/// The set of assemblies to register, or unregister.
///
[BuildElement("assemblies")]
public AssemblyFileSet Assemblies {
get { return _assemblies; }
set { _assemblies = value; }
}
///
/// The set of assembly references.
///
[BuildElement("references")]
public AssemblyFileSet References {
get { return _references; }
set { _references = value; }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Gets the working directory for the application.
///
///
/// The working directory for the application.
///
public override DirectoryInfo BaseDirectory {
get {
if (_workingDirectory == null) {
return base.BaseDirectory;
}
return _workingDirectory;
}
set {
_workingDirectory = value;
}
}
///
/// Gets the command line arguments for the external program.
///
///
/// The command line arguments for the external program.
///
public override string ProgramArguments {
get { return _arguments.ToString(); }
}
///
/// Gets the filename of the external program to start.
///
///
/// The filename of the external program.
///
///
/// Override in derived classes to explicitly set the location of the
/// external tool.
///
public override string ProgramFileName {
get {
if (_programFileName == null) {
_programFileName = base.ProgramFileName;
}
return _programFileName;
}
}
///
/// Updates the of the specified
/// .
///
/// The of which the should be updated.
protected override void PrepareProcess(Process process) {
// avoid copying the assembly references (and regasm) to a
// temporary directory if not necessary
if (References.FileNames.Count == 0) {
// further delegate preparation to base class
base.PrepareProcess(process);
// no further processing required
return;
}
// create instance of Copy task
CopyTask ct = new CopyTask();
// inherit project from current task
ct.Project = Project;
// inherit namespace manager from current task
ct.NamespaceManager = NamespaceManager;
// parent is current task
ct.Parent = this;
// inherit verbose setting from resgen task
ct.Verbose = Verbose;
// only output warning messages or higher, unless we're running
// in verbose mode
if (!ct.Verbose) {
ct.Threshold = Level.Warning;
}
// make sure framework specific information is set
ct.InitializeTaskConfiguration();
// set parent of child elements
ct.CopyFileSet.Parent = ct;
// inherit project from solution task for child elements
ct.CopyFileSet.Project = ct.Project;
// inherit namespace manager from solution task
ct.CopyFileSet.NamespaceManager = ct.NamespaceManager;
// set base directory of fileset
ct.CopyFileSet.BaseDirectory = Assemblies.BaseDirectory;
// copy all files to base directory itself
ct.Flatten = true;
// copy referenced assemblies
foreach (string file in References.FileNames) {
ct.CopyFileSet.Includes.Add(file);
}
// copy assemblies to register
foreach (string file in Assemblies.FileNames) {
ct.CopyFileSet.Includes.Add(file);
}
if (AssemblyFile != null) {
ct.CopyFileSet.Includes.Add(AssemblyFile.FullName);
}
// copy command line tool to working directory
ct.CopyFileSet.Includes.Add(base.ProgramFileName);
// set destination directory
ct.ToDirectory = BaseDirectory;
// increment indentation level
ct.Project.Indent();
try {
// execute task
ct.Execute();
} finally {
// restore indentation level
ct.Project.Unindent();
}
// change program to execute the tool in working directory as
// that will allow this tool to resolve assembly references
// using assemblies stored in the same directory
_programFileName = Path.Combine(BaseDirectory.FullName,
Path.GetFileName(base.ProgramFileName));
// further delegate preparation to base class
base.PrepareProcess(process);
}
#endregion Override implementation of ExternalProgramBase
#region Override implementation of Task
///
/// Registers or unregisters a single assembly, or a group of assemblies.
///
protected override void ExecuteTask() {
if (AssemblyFile == null && Assemblies.FileNames.Count == 0) {
return;
}
// when reference assembly are specified, we copy all references
// and all assemblies to a temp directory and run regasm from there
if (References.FileNames.Count != 0) {
// use a newly created temporary directory as working directory
BaseDirectory = FileUtils.GetTempDirectory();
}
if (Unregister) {
_arguments.Append(" /unregister");
}
if (TypeLib != null) {
_arguments.AppendFormat(CultureInfo.InvariantCulture,
" /tlb:\"{0}\"", TypeLib.FullName);
}
if (CodeBase) {
_arguments.Append(" /codebase");
}
if (RegistryFile != null) {
_arguments.AppendFormat(CultureInfo.InvariantCulture,
" /regfile:\"{0}\"", RegistryFile.FullName);
}
if (Registered) {
_arguments.Append(" /registered");
}
if (Verbose) {
_arguments.Append(" /verbose");
} else {
_arguments.Append(" /silent");
}
_arguments.Append(" /nologo");
if (AssemblyFile != null) {
Log(Level.Info, "{0} '{1}' for COM Interop",
Unregister ? "Unregistering" : "Registering",
AssemblyFile.FullName);
_arguments.AppendFormat(" \"{0}\"", GetAssemblyPath(
AssemblyFile.FullName));
} else {
// display build log message
Log(Level.Info, "{0} {1} files for COM interop",
Unregister ? "UnRegistering" : "Registering",
Assemblies.FileNames.Count);
// add files to command line
foreach (string path in Assemblies.FileNames) {
Log(Level.Verbose, "{0} '{1}' for COM Interop",
Unregister ? "UnRegistering" : "Registering",
path);
_arguments.AppendFormat(" \"{0}\"", GetAssemblyPath(path));
}
}
try {
// call base class to do the work
base.ExecuteTask();
} finally {
// we only need to remove temporary directory if it was
// actually created
if (_workingDirectory != null) {
// delete temporary directory and all files in it
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = Project;
deleteTask.Parent = this;
deleteTask.InitializeTaskConfiguration();
deleteTask.Directory = _workingDirectory;
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
}
}
#endregion Override implementation of Task
#region Private Instance Methods
private string GetAssemblyPath(string assembly) {
if (_workingDirectory == null) {
return assembly;
}
return Path.Combine(_workingDirectory.FullName,
Path.GetFileName(assembly));
}
#endregion Private Instance Methods
}
}
nant-0.92-rc1/src/NAnt.Win32/Tasks/MonoRegistryTask.cs 0000644 0001750 0001750 00000007061 11757302274 022265 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2002 Ryan Boggs
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Ryan Boggs (rmboggs@users.sourceforge.net)
using System;
using System.IO;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.Core.Attributes;
using Microsoft.Win32;
namespace NAnt.Win32.Tasks {
///
/// Reads the mono registry path into a NAnt property.
///
///
/// The mono registry keyes can exist in one of two places depending on the platform. This
/// task will check to see which registry path that Mono is using.
///
///
///
///
/// ]]>
///
///
[TaskName("monoregistry")]
internal class MonoRegistryTask : Task {
#region Private Static Fields
///
/// The Mono reg key to default to if none of the keys in _regKeys are found
/// in the running machine.
///
private const string _defaultRegKey = @"SOFTWARE\Mono";
#endregion Private Static Fields
#region Private Instance Fields
///
/// Private property name to assign the Mono registry path to.
///
private string _propName;
///
/// Private array of Mono registry paths to test in order.
///
///
/// If new registry paths are used by the Mono team, add them to this array.
///
private string[] _regKeys = new string[] {
@"SOFTWARE\Wow6432Node\Novell\Mono",
@"SOFTWARE\Novell\Mono"
};
#endregion Private Instance Fields
#region Public Instance Properties
///
///
/// The property to set to the Mono registry path.
///
///
[TaskAttribute("property", Required=true)]
[StringValidator(AllowEmpty=false)]
public virtual string PropertyName {
get { return _propName; }
set { _propName = value; }
}
#endregion Public Instance Properties
#region Override implementation of Task
///
/// Locates the appropriate Mono registry path to use.
///
protected override void ExecuteTask() {
foreach(string key in _regKeys) {
RegistryKey checkKey = Registry.LocalMachine.OpenSubKey(key);
if (checkKey != null) {
Properties[_propName] = key;
return;
}
}
// If none of the paths found in the _regKeys array, assign the default value
// to the property.
Properties[_propName] = _defaultRegKey;
}
#endregion Override implementation of Task
}
} nant-0.92-rc1/src/NAnt.Win32/Tasks/TlbExpTask.cs 0000644 0001750 0001750 00000017353 11757302274 021027 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Aaron Anderson (aaron@skypoint.com | aaron.anderson@farmcreditbank.com)
using System.Collections.Specialized;
using System.IO;
using System.Text;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
namespace NAnt.Win32.Tasks {
///
/// Exports a .NET assembly to a type library that can be used from unmanaged
/// code (wraps Microsoft's tlbexp.exe).
///
///
///
/// See the Microsoft.NET Framework SDK documentation for details.
///
///
///
/// Export DotNetAssembly.dll to LegacyCOM.dll.
///
///
/// ]]>
///
///
[TaskName("tlbexp")]
[ProgramLocation(LocationType.FrameworkSdkDir)]
public class TlbExpTask : ExternalProgramBase {
#region Private Instance Fields
private FileInfo _assemblyFile;
private FileInfo _outputFile;
private FileInfo _namesFile;
private StringBuilder _argumentBuilder;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Specifies the assembly for which to export a type library.
///
///
/// The assembly for which to export a type library.
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("assembly", Required=true)]
public FileInfo AssemblyFile {
get { return _assemblyFile; }
set { _assemblyFile = value; }
}
///
/// Specifies the name of the type library file to generate.
///
///
/// The name of the type library file to generate.
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("output", Required=true)]
public FileInfo OutputFile {
get { return _outputFile; }
set { _outputFile = value; }
}
///
/// Specifies the file used to determine capitalization of names in a
/// type library.
///
///
/// The file used to determine capitalization of names in a type library.
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("names")]
public FileInfo NamesFile {
get { return _namesFile; }
set { _namesFile = value; }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Gets the command line arguments for the external program.
///
///
/// The command line arguments for the external program.
///
public override string ProgramArguments {
get {
if (_argumentBuilder != null) {
return _argumentBuilder.ToString();
} else {
return null;
}
}
}
///
/// Exports the type library.
///
protected override void ExecuteTask() {
//Check to see if any of the underlying interop dlls or the typelibs have changed
//Otherwise, it's not necessary to reimport.
if (NeedsCompiling()) {
//Using a stringbuilder vs. StreamWriter since this program will not accept response files.
_argumentBuilder = new StringBuilder();
_argumentBuilder.Append("\"" + AssemblyFile.FullName + "\"");
// Any option that specifies a file name must be wrapped in quotes
// to handle cases with spaces in the path.
_argumentBuilder.AppendFormat(" /out:\"{0}\"", OutputFile.FullName);
// suppresses the Microsoft startup banner display
_argumentBuilder.Append(" /nologo");
if (Verbose) {
// displays extra information
_argumentBuilder.Append(" /verbose");
} else {
// suppresses all output except for errors
_argumentBuilder.Append(" /silent");
}
// filename used to determine capitalization of names in typelib
if (NamesFile != null) {
_argumentBuilder.AppendFormat(" /names:\"{0}\"", NamesFile.FullName);
}
// call base class to do the work
base.ExecuteTask();
}
}
#endregion Override implementation of ExternalProgramBase
#region Protected Instance Methods
///
/// Determines whether the assembly needs to be exported to a type
/// library again.
///
///
/// if the assembly needs to be exported to a
/// type library; otherwise, .
///
protected virtual bool NeedsCompiling() {
// return true as soon as we know we need to compile
if (!OutputFile.Exists) {
Log(Level.Verbose, "Output file '{0}' does not exist, recompiling.",
OutputFile.FullName);
return true;
}
// check if the assembly was changed since the typelib was generated
string fileName = FileSet.FindMoreRecentLastWriteTime(AssemblyFile.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, recompiling.",
fileName);
return true;
}
// check if the names file was changed since the typelib was generated
if (NamesFile != null) {
fileName = FileSet.FindMoreRecentLastWriteTime(NamesFile.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, recompiling.",
fileName);
return true;
}
}
// if we made it here then we don't have to export the assembly again.
return false;
}
#endregion Protected Instance Methods
}
}
nant-0.92-rc1/src/NAnt.Win32/Tasks/LocateSdkTask.cs 0000644 0001750 0001750 00000030437 11757302274 021500 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2002 Ryan Boggs
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Ryan Boggs (rmboggs@users.sourceforge.net)
using System;
using System.Text.RegularExpressions;
using System.IO;
using System.Xml;
using System.Globalization;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.Core.Attributes;
using Microsoft.Win32;
namespace NAnt.Win32.Tasks {
///
/// Reads the most recent Windows SDK InstallationFolder key into a NAnt property
///
///
///
///
/// ]]>
///
///
[TaskName("locatesdk")]
internal class LocateSdkTask : Task {
#region Private Instance Fields
private string _propName;
private string _minWinSdkVer = "v6.0";
private string _maxWinSdkVer;
private string _minNetFxVer = "2.0";
private string _maxNetFxVer;
private readonly string _registryBase = @"SOFTWARE\Microsoft\Microsoft SDKs\Windows";
private readonly string _regexNetFxTools = @"^WinSDK.*NetFx.*Tools.*$";
#endregion Private Instance Fields
#region Public Instance Properties
///
///
/// The property to set to the value stored in the InstalledFolder key of the located WinSDK version.
///
///
[TaskAttribute("property", Required=true)]
[StringValidator(AllowEmpty=false)]
public virtual string PropertyName {
get { return _propName; }
set { _propName = value; }
}
///
///
/// The minimum acceptable Windows SDK version.
///
///
[TaskAttribute("minwinsdkver")]
public string MinWinSdkVersion {
get { return _minWinSdkVer; }
set { _minWinSdkVer = value; }
}
///
///
/// The maximum acceptable Windows SDK version.
///
///
[TaskAttribute("maxwinsdkver")]
public string MaxWinSdkVersion {
get { return _maxWinSdkVer; }
set { _maxWinSdkVer = value; }
}
///
///
/// The minimum acceptable .NET sdk version.
///
///
[TaskAttribute("minnetfxver")]
public string MinNetFxVersion {
get { return _minNetFxVer; }
set { _minNetFxVer = value; }
}
///
///
/// The maximum acceptable .NET sdk version.
///
///
[TaskAttribute("maxnetfxver")]
public string MaxNetFxVersion {
get { return _maxNetFxVer; }
set { _maxNetFxVer = value; }
}
#endregion Public Instance Properties
#region Override implementation of Task
///
/// locate the most recent WinSDK installed
///
protected override void ExecuteTask() {
// Initialize all necessary Version objects
// These will hold the min, max, and loop WinSDK versions found
Version minSdkVersion = StringToVersion(_minWinSdkVer);
Version maxSdkVersion = StringToVersion(_maxWinSdkVer);
Version loopSdkVersion = null;
// These will hold the min, max, and loop .NET versions found
Version minNetVersion = StringToVersion(_minNetFxVer);
Version maxNetVersion = StringToVersion(_maxNetFxVer);
Version loopNetVersion = null;
// Bool variable used to indicate that a valid SDK was found
bool sdkFound = false;
// Get all of the WinSDK version keys from the user's registry and
// load them into a string array.
RegistryKey sdkRegSubKey = Registry.LocalMachine.OpenSubKey(_registryBase, false);
string[] installedWinSdkVersions = sdkRegSubKey.GetSubKeyNames();
// Sort and reverse the WinSDK version key array to make sure that
// the latest version is reviewed first before reviewing earlier
// versions.
Array.Sort(installedWinSdkVersions);
Array.Reverse(installedWinSdkVersions);
// Loop through all of the WinSDK version keys.
for(int i = 0; i < installedWinSdkVersions.Length; i++) {
loopSdkVersion = StringToVersion(installedWinSdkVersions[i]);
// If a maxVersion was indicated and the loopVersion is greater than
// the maxVersion, skip to the next item in the installedVersion array.
if (maxSdkVersion != null) {
if (loopSdkVersion > maxSdkVersion) {
continue;
}
}
// If the loopVersion is greater than or equal to the minVersion, loop through the subkeys
// for a valid .NET sdk path
if (minSdkVersion <= loopSdkVersion) {
// Gets all of the current WinSdk loop subkeys
string[] installedWinSdkSubKeys = sdkRegSubKey.OpenSubKey(installedWinSdkVersions[i]).GetSubKeyNames();
// Sort and reverse the order of the subkeys to go from greatest to least
Array.Sort(installedWinSdkSubKeys);
Array.Reverse(installedWinSdkSubKeys);
// Loop through all of the current WinSdk loop subkeys
for(int j = 0; j < installedWinSdkSubKeys.Length; j++) {
// Check to see if the current subkey matches the RegEx string
if (Regex.IsMatch(installedWinSdkSubKeys[j], _regexNetFxTools)) {
// Initialize the necessary string array to hold all
// possible directory locations
string[] netFxDirs = new string[] {
sdkRegSubKey.OpenSubKey(installedWinSdkVersions[i]).OpenSubKey(installedWinSdkSubKeys[j]).GetValue("InstallationFolder").ToString(),
Path.Combine(sdkRegSubKey.OpenSubKey(installedWinSdkVersions[i]).OpenSubKey(installedWinSdkSubKeys[j]).GetValue("InstallationFolder").ToString(), "bin")
};
// Loop through all of the directories in the possible directory
// locations array
foreach(string netFxDir in netFxDirs) {
// Set the full path to the gacutil.exe.config file based on the current
// directory in the directories array
string netFxXmlFile = Path.Combine(netFxDir, "gacutil.exe.config");
// If the full file path exists, load the gacutil.exe.config xml file
if (File.Exists(netFxXmlFile)) {
XmlDocument gacXmlDoc = new XmlDocument();
gacXmlDoc.Load(netFxXmlFile);
// Get the supported runtime version from the version attribute
// and load it into the loopNetVersion Version object to use for
// comparisons
XmlNode gacVersion = gacXmlDoc.SelectSingleNode("/configuration/startup/requiredRuntime");
XmlAttribute versionAttribute = gacVersion.Attributes["version"];
loopNetVersion = StringToVersion(versionAttribute.Value.ToString());
// If the maxNetVersion object is not null and is less than
// the loopNetVersion, continue to the next iteration of the
// inner loop
if (maxNetVersion != null) {
if (loopNetVersion > maxNetVersion) {
continue;
}
}
// If loopNetVersion is greater than or equal to minNetVersion
// assign the value of the InstallationFolder key of the current subfolder
// to the property name and exit the inner loop
if (minNetVersion <= loopNetVersion) {
Properties[_propName] = netFxDir;
sdkFound = true;
break;
}
}
}
}
}
// If a valid Sdk version was found within the current Sdk subkeys, break
// the outer loop.
if (sdkFound) {
break;
}
}
}
// if the Properties dictionary does not contain the _propName as a key, throw an error.
if (!sdkFound) {
throw new BuildException(String.Format(CultureInfo.InvariantCulture,"System does not have minimum specified Windows SDK {0}!", _minWinSdkVer));
}
}
#endregion Override implementation of Task
#region Private Instance Methods
///
/// Converts a version expressed as a string into a Version object
///
///
/// A containing the version to convert.
///
///
/// A object representing the version string.
///
private Version StringToVersion(string sdkVersion) {
if (!String.IsNullOrEmpty(sdkVersion)) {
// Make any non-numeric characters uppercase
sdkVersion = sdkVersion.Trim().ToUpper();
// Remove the leading v from the sdkVersion string
if (sdkVersion.StartsWith("V")) {
sdkVersion = sdkVersion.Substring(1);
}
// Return a new Version object based on the sdkVersion string
// If the sdkVersion string ends with an alphanumeric, it is
// converted to a revision number for comparison purposes
if (!char.IsNumber(sdkVersion, sdkVersion.Length - 1)) {
string sdkVerFormat = sdkVersion.Substring(0, sdkVersion.Length -1) + "." +
((int)sdkVersion.ToCharArray()[sdkVersion.Length - 1]).ToString();
return new Version(sdkVerFormat);
} else {
return new Version(sdkVersion);
}
// If the sdkVersion parameter is null or empty, return null
} else {
return null;
}
}
#endregion Private Instance Methods
}
}
nant-0.92-rc1/src/NAnt.Win32/Tasks/AxImpTask.cs 0000644 0001750 0001750 00000025542 11757302274 020646 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Jayme C. Edwards (jedwards@wi.rr.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Globalization;
using System.IO;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
namespace NAnt.Win32.Tasks {
///
/// Generates a Windows Forms Control that wraps ActiveX Controls defined
/// in an OCX.
///
///
///
///
/// ]]>
///
///
[TaskName("aximp")]
[ProgramLocation(LocationType.FrameworkSdkDir)]
public class AxImpTask : ExternalProgramBase {
#region Private Instance Fields
private FileInfo _ocxFile;
private FileInfo _outputFile;
private FileInfo _publicKeyFile;
private FileInfo _keyFile;
private FileInfo _rcwFile;
private string _keyContainer;
private bool _delaySign;
private bool _generateSource;
// framework configuration settings
private bool _supportsRcw = true;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Filename of the .ocx file.
///
[TaskAttribute("ocx", Required=true)]
public FileInfo OcxFile {
get { return _ocxFile; }
set { _ocxFile = value; }
}
///
/// Filename of the generated assembly.
///
[TaskAttribute("output")]
public FileInfo OutputFile {
get { return _outputFile; }
set { _outputFile = value; }
}
///
/// Specifies the file containing the public key to use to sign the
/// resulting assembly.
///
///
/// The file containing the public key to use to sign the resulting
/// assembly.
///
[TaskAttribute("publickey")]
public FileInfo PublicKeyFile {
get { return _publicKeyFile; }
set { _publicKeyFile = value; }
}
///
/// Specifies the publisher's official public/private key pair with which
/// the resulting assembly should be signed with a strong name.
///
///
/// The keyfile to use to sign the resulting assembly with a strong name.
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("keyfile")]
public FileInfo KeyFile {
get { return _keyFile; }
set { _keyFile = value; }
}
///
/// Specifies the key container in which the public/private key pair
/// should be found that should be used to sign the resulting assembly
/// with a strong name.
///
///
/// The key container containing a public/private key pair that should
/// be used to sign the resulting assembly.
///
[TaskAttribute("keycontainer")]
public string KeyContainer {
get { return _keyContainer; }
set { _keyContainer = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies to sign the resulting control using delayed signing.
///
[TaskAttribute("delaysign")]
[BooleanValidator()]
public bool DelaySign {
get { return _delaySign; }
set { _delaySign = value; }
}
///
/// Determines whether C# source code for the Windows Form wrapper should
/// be generated. The default is .
///
[TaskAttribute("generatesource")]
[BooleanValidator()]
public bool GenerateSource {
get { return _generateSource; }
set { _generateSource = value; }
}
///
/// Assembly to use for Runtime Callable Wrapper rather than generating
/// new one [.NET 1.1 or higher].
///
[TaskAttribute("rcw")]
public FileInfo RcwFile {
get { return _rcwFile; }
set { _rcwFile = value; }
}
///
/// Indicates whether aximp supports using an existing Runtime
/// Callable Wrapper for a given target framework. The default is
/// .
///
[FrameworkConfigurable("supportsrcw")]
public bool SupportsRcw {
get { return _supportsRcw; }
set { _supportsRcw = value; }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Gets the command-line arguments for the external program.
///
///
/// The command-line arguments for the external program.
///
public override string ProgramArguments {
get { return ""; }
}
///
/// Import the ActiveX control.
///
protected override void ExecuteTask() {
Log(Level.Info, "Generating Windows Forms Control wrapping '{0}'.",
OcxFile.FullName);
if (!NeedsCompiling()) {
return;
}
if (DelaySign) {
Arguments.Add(new Argument("/delaysign"));
}
if (GenerateSource) {
Arguments.Add(new Argument("/source"));
}
if (Verbose) {
Arguments.Add(new Argument("/verbose"));
} else {
Arguments.Add(new Argument("/silent"));
}
if (OutputFile != null) {
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/out:\"{0}\"", OutputFile.FullName)));
}
if (PublicKeyFile != null) {
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/publickey:\"{0}\"", PublicKeyFile.FullName)));
}
if (KeyFile != null) {
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/keyfile:\"{0}\"", KeyFile.FullName)));
}
if (KeyContainer != null) {
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/keycontainer:\"{0}\"", KeyContainer)));
}
if (RcwFile != null) {
if (SupportsRcw) {
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/rcw:\"{0}\"", RcwFile.FullName)));
}
}
// suppresses display of the sign-on banner
Arguments.Add(new Argument("/nologo"));
Arguments.Add(new Argument(OcxFile));
try {
base.ExecuteTask();
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Error importing ActiveX control from '{0}'.", OcxFile.FullName),
Location, ex);
}
}
#endregion Override implementation of ExternalProgramBase
#region Protected Instance Methods
///
/// Determines whether the assembly needs to be created again.
///
///
/// if the assembly needs to be created again;
/// otherwise, .
///
protected virtual bool NeedsCompiling() {
// return true as soon as we know we need to compile
if (!OutputFile.Exists) {
Log(Level.Verbose, "Output file '{0}' does not exist, recompiling.",
OutputFile.FullName);
return true;
}
// check if the ocx was changed since the assembly was generated
string fileName = FileSet.FindMoreRecentLastWriteTime(OcxFile.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, recompiling.",
fileName);
return true;
}
// check if the public key file was changed since the assembly was
// generated
if (PublicKeyFile != null) {
fileName = FileSet.FindMoreRecentLastWriteTime(PublicKeyFile.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, recompiling.",
fileName);
return true;
}
}
// check if the key file was changed since the assembly was generated
if (KeyFile != null) {
fileName = FileSet.FindMoreRecentLastWriteTime(KeyFile.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, recompiling.",
fileName);
return true;
}
}
// check if the Runtime Callable Wrapper file was changed since the
// assembly was generated
if (RcwFile != null) {
fileName = FileSet.FindMoreRecentLastWriteTime(RcwFile.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, recompiling.",
fileName);
return true;
}
}
// if we made it here then we don't have to export the assembly again.
return false;
}
#endregion Protected Instance Methods
}
}
nant-0.92-rc1/src/NAnt.Win32/Tasks/ReadRegistryTask.cs 0000644 0001750 0001750 00000020467 11757302274 022235 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2002 Scott Hernandez
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Scott Hernandez (ScottHernandez@hotmail.com)
using System;
using System.Globalization;
using System.Security.Permissions;
using Microsoft.Win32;
using NAnt.Core;
using NAnt.Core.Attributes;
#if (!NET_4_0)
[assembly: RegistryPermissionAttribute(SecurityAction.RequestMinimum , Unrestricted=true)]
#endif
namespace NAnt.Win32.Tasks {
///
/// Reads a value or set of values from the Windows Registry into one or
/// more NAnt properties.
///
///
/// Read a single value from the registry.
///
///
/// ]]>
///
/// Read all the registry values in a key.
///
///
/// ]]>
///
///
[TaskName("readregistry")]
public class ReadRegistryTask : Task {
#region Private Instance Fields
private string _propName;
private string _propPrefix;
private string _regKey;
private string _regKeyValueName;
private RegistryHive[] _regHive = {RegistryHive.LocalMachine};
private string _regHiveString = RegistryHive.LocalMachine.ToString();
#endregion Private Instance Fields
#region Public Instance Properties
///
/// The property to set to the specified registry key value.
/// If this attribute is used then a single value will be read.
///
[TaskAttribute("property")]
public virtual string PropertyName {
get { return _propName; }
set { _propName = value; }
}
///
/// The prefix to use for the specified registry key values.
/// If this attribute is used then all registry values will be read and stored as properties with this prefix.
///
///
/// Registry values a, b, c will be turned into prefixa, prefixb, prefixc named properties
///
[TaskAttribute("prefix")]
public virtual string PropertyPrefix {
get { return _propPrefix; }
set { _propPrefix = value; }
}
///
/// The registry key to read, including the path.
///
///
/// SOFTWARE\Microsoft\.NETFramework\sdkInstallRoot
///
[TaskAttribute("key", Required=true)]
[StringValidator(AllowEmpty=false)]
public virtual string RegistryKey {
get { return _regKey; }
set {
string key = value;
if(value.StartsWith("\\")) {
key = value.Substring(1);
}
string[] pathParts = key.Split("\\".ToCharArray(0,1)[0]);
//split the key/path apart.
_regKeyValueName = pathParts[pathParts.Length - 1];
_regKey = key.Substring(0, (value.Length - _regKeyValueName.Length));
}
}
///
/// Space separated list of registry hives to search for .
/// For a list of possible values, see . The
/// default is .
///
///
///
///
[TaskAttribute("hive")]
public virtual string RegistryHiveName {
get { return _regHiveString; }
set {
_regHiveString = value;
string[] tempRegHive = _regHiveString.Split(" ".ToCharArray()[0]);
_regHive = (RegistryHive[]) Array.CreateInstance(typeof(RegistryHive), tempRegHive.Length);
for (int x=0; x
/// read the specified registry value
///
protected override void ExecuteTask() {
object regKeyValue = null;
if (_regKey == null) {
throw new BuildException("Missing registry key!");
}
RegistryKey mykey = null;
if (_propName != null) {
mykey = LookupRegKey(_regKey, _regHive);
regKeyValue = mykey.GetValue(_regKeyValueName);
if (regKeyValue != null) {
string val = regKeyValue.ToString();
Properties[_propName] = val;
} else {
throw new BuildException(String.Format(CultureInfo.InvariantCulture, "Registry Value Not Found! - key='{0}';hive='{1}';", _regKey + "\\" + _regKeyValueName, _regHiveString));
}
} else if (_propName == null && _propPrefix != null) {
mykey = LookupRegKey(_regKey, _regHive);
foreach (string name in mykey.GetValueNames()) {
Properties[_propPrefix + "." + name] = mykey.GetValue(name).ToString();
}
} else {
throw new BuildException("Missing both a property name and property prefix; atleast one if required!");
}
}
#endregion Override implementation of Task
#region Protected Instance Methods
///
/// Returns the hive for a given key.
///
///
///
///
/// The hive for a given key.
///
protected RegistryKey LookupRegKey(string key, RegistryHive[] registries) {
foreach (RegistryHive hive in registries) {
Log(Level.Verbose, "Opening {0}:{1}.", hive.ToString(), key);
RegistryKey returnkey = GetHiveKey(hive).OpenSubKey(key, false);
if (returnkey != null) {
return returnkey;
}
}
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Registry Path Not Found! - key='{0}';hive='{1}';", key,
_regHiveString));
}
///
/// Returns the key for a given registry hive.
///
/// The registry hive to return the key for.
///
/// The key for a given registry hive.
///
protected RegistryKey GetHiveKey(RegistryHive hive) {
switch(hive) {
case RegistryHive.LocalMachine:
return Registry.LocalMachine;
case RegistryHive.Users:
return Registry.Users;
case RegistryHive.CurrentUser:
return Registry.CurrentUser;
case RegistryHive.ClassesRoot:
return Registry.ClassesRoot;
default:
Log(Level.Verbose, "Registry not found for {0}.",
hive.ToString());
return null;
}
}
#endregion Protected Instance Methods
}
}
nant-0.92-rc1/src/NAnt.Win32/Tasks/TlbImpTask.cs 0000644 0001750 0001750 00000047716 11757302274 021026 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Aaron Anderson (gerry_shaw@yahoo.com)
// Ian MacLean (ian@maclean.ms)
using System.Collections.Specialized;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using NAnt.DotNet.Types;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
namespace NAnt.Win32.Tasks {
///
/// Imports a type library to a .NET assembly (wraps Microsoft's tlbimp.exe).
///
///
///
/// This task lets you easily create interop assemblies. By default, it will
/// not reimport if the underlying COM TypeLib or reference has not changed.
///
///
/// See the Microsoft.NET Framework SDK documentation for details.
///
///
///
/// Import LegacyCOM.dll to DotNetAssembly.dll.
///
///
/// ]]>
///
///
///
///
/// Generate an assembly named "Interop.MSVidCtlLib.dll" for the
/// MS Video Control 1.0 Type Library, transforming any [out, retval]
/// parameters of methods on dispinterfaces in the type library into
/// return values in the managed library.
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("tlbimp")]
[ProgramLocation(LocationType.FrameworkSdkDir)]
public class TlbImpTask : ExternalProgramBase {
#region Private Instance Fields
private FileInfo _outputFile;
private string _namespace;
private string _asmVersion;
private bool _delaySign;
private bool _primary;
private FileInfo _publicKeyFile;
private FileInfo _keyFile;
private string _keyContainer;
private AssemblyFileSet _references = new AssemblyFileSet();
private bool _strictref;
private bool _sysarray;
private string _transform;
private bool _unsafe;
private FileInfo _typelib;
private StringBuilder _argumentBuilder;
// framework configuration settings
private bool _supportsTransform = true;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Specifies the name of the output file.
///
///
/// The name of the output file.
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("output", Required=true)]
public FileInfo OutputFile {
get { return _outputFile; }
set { _outputFile = value; }
}
///
/// Specifies the namespace in which to produce the assembly.
///
///
/// The namespace in which to produce the assembly.
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("namespace")]
public string Namespace {
get { return _namespace; }
set { _namespace = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the version number of the assembly to produce.
///
///
///
/// The version number of the assembly to produce.
///
///
/// The version number should be in the format major.minor.build.revision.
///
///
/// See the Microsoft.NET Framework SDK documentation for details.
///
///
[TaskAttribute("asmversion")]
public string AsmVersion {
get { return _asmVersion; }
set { _asmVersion = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies whether the resulting assembly should be signed with a
/// strong name using delayed signing. The default is .
///
///
/// if the resulting assembly should be signed
/// with a strong name using delayed signing; otherwise, .
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("delaysign")]
[BooleanValidator()]
public bool DelaySign {
get { return _delaySign; }
set { _delaySign = value; }
}
///
/// Specifies whether a primary interop assembly should be produced for
/// the specified type library. The default is .
///
///
/// if a primary interop assembly should be
/// produced; otherwise, .
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("primary")]
[BooleanValidator()]
public bool Primary {
get { return _primary; }
set { _primary = value; }
}
///
/// Specifies the file containing the public key to use to sign the
/// resulting assembly.
///
///
/// The file containing the public key to use to sign the resulting
/// assembly.
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("publickey")]
public FileInfo PublicKeyFile {
get { return _publicKeyFile; }
set { _publicKeyFile = value; }
}
///
/// Specifies the publisher's official public/private key pair with which
/// the resulting assembly should be signed with a strong name.
///
///
/// The keyfile to use to sign the resulting assembly with a strong name.
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("keyfile")]
public FileInfo KeyFile {
get { return _keyFile; }
set { _keyFile = value; }
}
///
/// Specifies the key container in which the public/private key pair
/// should be found that should be used to sign the resulting assembly
/// with a strong name.
///
///
/// The key container containing a public/private key pair that should
/// be used to sign the resulting assembly.
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("keycontainer")]
public string KeyContainer {
get { return _keyContainer; }
set {_keyContainer = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the assembly files to use to resolve references to types
/// defined outside the current type library.
///
///
/// The assembly files to use to resolve references to types defined
/// outside the current type library.
///
/// See the Microsoft.NET Framework SDK documentation for details.
[BuildElement("references")]
public AssemblyFileSet References {
get { return _references; }
set { _references = value; }
}
///
/// Specifies whether a type library should not be imported if all
/// references within the current assembly or the reference assemblies
/// cannot be resolved. The default is .
///
///
/// if a type library should not be imported if
/// all references cannot be resolved; otherwise, .
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("strictref")]
[BooleanValidator()]
public bool StrictRef {
get { return _strictref; }
set { _strictref = value; }
}
///
/// Specifies whether to import a COM style SafeArray as a managed
/// class type. The default is .
///
///
/// if a COM style SafeArray should be imported
/// as a managed class type; otherwise,
/// .
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("sysarray")]
[BooleanValidator()]
public bool SysArray {
get { return _sysarray; }
set { _sysarray = value; }
}
///
/// Specifies how to transform the metadata [.NET 1.1 or higher].
///
[TaskAttribute("transform")]
public string Transform {
get { return _transform; }
set { _transform = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the source type library that gets passed to the type
/// library importer.
///
///
/// The source type library that gets passed to the type library
/// importer.
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("typelib", Required=true)]
public FileInfo TypeLib {
get { return _typelib; }
set { _typelib = value; }
}
///
/// Specifies whether interfaces should be produced without .NET Framework
/// security checks. The default is .
///
///
/// if interfaces without .NET Framework security
/// checks should be produced; otherwise, .
///
/// See the Microsoft.NET Framework SDK documentation for details.
[TaskAttribute("unsafe")]
[BooleanValidator()]
public bool Unsafe {
get { return _unsafe; }
set { _unsafe = value; }
}
///
/// Indicates whether tlbimp supports transforming metadata for
/// a given target framework. The default is .
///
[FrameworkConfigurable("supportstransform")]
public bool SupportsTransform {
get { return _supportsTransform; }
set { _supportsTransform = value; }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Gets the command line arguments for the external program.
///
///
/// The command line arguments for the external program.
///
public override string ProgramArguments {
get {
if (_argumentBuilder != null) {
return _argumentBuilder.ToString();
} else {
return null;
}
}
}
///
/// Imports the type library to a .NET assembly.
///
protected override void ExecuteTask() {
// ensure base directory is set, even if fileset was not initialized
// from XML
if (References.BaseDirectory == null) {
References.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
// check to see if any of the underlying interop dlls or the typelibs have changed
// otherwise, it's not necessary to reimport.
if (NeedsCompiling()) {
// using a stringbuilder vs. StreamWriter since this program will not accept response files.
_argumentBuilder = new StringBuilder();
_argumentBuilder.Append("\"" + TypeLib.FullName + "\"");
// any option that specifies a file name must be wrapped in quotes
// to handle cases with spaces in the path.
_argumentBuilder.AppendFormat(" /out:\"{0}\"", OutputFile.FullName);
// suppresses the Microsoft startup banner display
_argumentBuilder.Append(" /nologo");
if (AsmVersion != null) {
_argumentBuilder.AppendFormat(" /asmversion:\"{0}\"", AsmVersion);
}
if (Namespace != null) {
_argumentBuilder.AppendFormat(" /namespace:\"{0}\"", Namespace);
}
if (Primary) {
_argumentBuilder.Append(" /primary");
}
if (Unsafe) {
_argumentBuilder.Append(" /unsafe");
}
if (DelaySign) {
_argumentBuilder.Append(" /delaysign");
}
if (PublicKeyFile != null) {
_argumentBuilder.AppendFormat(" /publickey:\"{0}\"", PublicKeyFile.FullName);
}
if (KeyFile != null) {
_argumentBuilder.AppendFormat(" /keyfile:\"{0}\"", KeyFile.FullName);
}
if (KeyContainer != null) {
_argumentBuilder.AppendFormat(" /keycontainer:\"{0}\"", KeyContainer);
}
if (StrictRef) {
_argumentBuilder.Append(" /strictref");
}
if (SysArray) {
_argumentBuilder.Append(" /sysarray");
}
if (Transform != null) {
if (SupportsTransform) {
_argumentBuilder.AppendFormat(" /transform:\"{0}\"", Transform);
}
}
if (Verbose) {
// displays extra information
_argumentBuilder.Append(" /verbose");
} else {
// suppresses all output except for errors
_argumentBuilder.Append(" /silent");
}
foreach (string fileName in References.FileNames) {
_argumentBuilder.AppendFormat(" /reference:\"{0}\"", fileName);
}
// call base class to do the work
base.ExecuteTask();
}
}
#endregion Override implementation of ExternalProgramBase
#region Public Static Methods
///
/// Returns the path of the type library, removing the identifier of
/// the type library from the specified string.
///
/// The path from which to extract the path of the type library.
///
/// The path of the type library without the type library identifier.
///
///
/// An example of a path which includes the identifier of the type
/// library (in this case "2") is
/// C:\WINDOWS\system32\msvidctl.dll\2.
///
public static string ExtractTypeLibPath(string path) {
Regex regex = new Regex(@"^.*\\\d+$", RegexOptions.IgnorePatternWhitespace
| RegexOptions.Multiline | RegexOptions.IgnoreCase);
if (regex.IsMatch(path)) {
return path.Substring(0, path.LastIndexOf("\\"));
}
return path;
}
#endregion Public Static Methods
#region Protected Instance Methods
///
/// Determines whether the type library needs to be imported again.
///
///
/// if the type library needs to be imported;
/// otherwise, .
///
protected virtual bool NeedsCompiling() {
// return true as soon as we know we need to compile
if (!OutputFile.Exists) {
Log(Level.Verbose, "Output file '{0}' does not exist, recompiling.",
OutputFile.FullName);
return true;
}
string typeLibPath = ExtractTypeLibPath(TypeLib.FullName);
// check if the type library was updated since the interop assembly was generated
string fileName = FileSet.FindMoreRecentLastWriteTime(typeLibPath, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, recompiling.",
fileName);
return true;
}
// check if the reference assemblies were updated since the interop assembly was generated
fileName = FileSet.FindMoreRecentLastWriteTime(References.FileNames, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, recompiling.",
fileName);
return true;
}
// if we made it here then we don't have to reimport the typelib.
return false;
}
#endregion Protected Instance Methods
}
}
nant-0.92-rc1/src/CommonAssemblyInfo.cs 0000644 0001750 0001750 00000002137 11757303362 017715 0 ustar jtaylor jtaylor using System;
using System.Reflection;
using System.Runtime.InteropServices;
//------------------------------------------------------------------------------
//
// This code was generated by a tool.
// Runtime Version:4.0.30319.269
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
//
//------------------------------------------------------------------------------
[assembly: ComVisibleAttribute(false)]
[assembly: CLSCompliantAttribute(true)]
[assembly: AssemblyTitleAttribute("NAnt")]
[assembly: AssemblyDescriptionAttribute("A .NET Build Tool")]
[assembly: AssemblyConfigurationAttribute("rc1")]
[assembly: AssemblyCompanyAttribute("http://nant.sourceforge.net")]
[assembly: AssemblyProductAttribute("NAnt")]
[assembly: AssemblyCopyrightAttribute("Copyright (C) 2001-2012 Gerry Shaw")]
[assembly: AssemblyTrademarkAttribute("")]
[assembly: AssemblyCultureAttribute("")]
[assembly: AssemblyVersionAttribute("0.92.4526.0")]
[assembly: AssemblyInformationalVersionAttribute("0.92")]
nant-0.92-rc1/src/NAnt.MSNet/ 0000755 0001750 0001750 00000000000 11757310030 015432 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.MSNet/AssemblyInfo.cs 0000644 0001750 0001750 00000002205 11757302274 020366 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System.Reflection;
// This will not compile with Visual Studio. If you want to build a signed
// executable use the NAnt build file. To build under Visual Studio just
// exclude this file from the build.
[assembly: AssemblyDelaySign(false)]
//[assembly: AssemblyKeyFile(@"..\NAnt.key")]
[assembly: AssemblyKeyName("")] nant-0.92-rc1/src/NAnt.MSNet/Resources/ 0000755 0001750 0001750 00000000000 11757310030 017404 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.MSNet/Resources/Strings.resx 0000644 0001750 0001750 00000012647 11757302274 021765 0 ustar jtaylor jtaylor
text/microsoft-resx1.0System.Resources.ResXResourceReaderSystem.Resources.ResXResourceWriterThe 'todir' should be set when using the <assemblies> element to specify the list of PE files to disassemble.The 'todir' should be set when using the <assemblies> element to specify the list of PE files to disassemble.The 'input' attribute and the <assemblies> element cannot be combined.The 'input' attribute and the <assemblies> element cannot be combined.Either the 'output' or 'todir' attribute should be set.Either the 'output' or 'todir' attribute should be set.The 'output' and 'todir' attribute cannot both be set.The 'output' and 'todir' attribute cannot both be set.Input file '{0}' does not exist.Input file '{0}' does not exist.The output file for '{0}' could not be determined.The output file for '{0}' could not be determined.Cannot start service {0} on computer '{1}'.Cannot start service {0} on computer '{1}'.Cannot stop service {0} on computer '{1}'.Cannot stop service {0} on computer '{1}'.Cannot pause service {0} on computer '{1}'.Cannot pause service {0} on computer '{1}'.Cannot pause service {0} on computer '{1}' as its not currently started.Cannot pause service {0} on computer '{1}' as its not currently started.Cannot pause service {0} on computer '{1}' as it does not support the pause and continue mechanism.Cannot pause service {0} on computer '{1}' as it does not support the pause and continue mechanism.Cannot continue service {0} on computer '{1}'.Cannot continue service {0} on computer '{1}'.Cannot continue service {0} on computer '{1} as its not currently started.Cannot continue service {0} on computer '{1} as its not currently started.Cannot continue service {0} on computer '{1} as it does not support the pause and continue mechanism.Cannot continue service {0} on computer '{1} as it does not support the pause and continue mechanism.Cannot continue service {0} on computer '{1} as its not currently running or paused.Cannot continue service {0} on computer '{1} as its not currently running or paused.Disassembling '{0}' to '{1}'.Disassembling '{0}' to '{1}'.'rebuild' attribute set to true, disassembling.'rebuild' attribute set to true, disassembling.Output file '{0}' does not exist, disassembling.Output file '{0}' does not exist, disassembling.'{0}' has been updated, disassembling.'{0}' has been updated, disassembling.
nant-0.92-rc1/src/NAnt.MSNet/NAnt.MSNet.build 0000644 0001750 0001750 00000003543 11757302274 020320 0 ustar jtaylor jtaylor
nant-0.92-rc1/src/NAnt.MSNet/Tasks/ 0000755 0001750 0001750 00000000000 11757310030 016517 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.MSNet/Tasks/IldasmTask.cs 0000644 0001750 0001750 00000065435 11757302274 021132 0 ustar jtaylor jtaylor // IldasmTask.cs
//
// Giuseppe Greco
// Copyright (C) 2004 Agamura, Inc.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Giuseppe Greco (giuseppe.greco@agamura.com)
using System.Globalization;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
namespace NAnt.MSNet.Tasks {
///
/// Disassembles any portable executable (PE) file that contains
/// intermediate language (IL) code.
///
///
///
/// Files are only disassembled if the input file is newer than the output
/// file, or if the output file does not exist. However, you can
/// explicitly force files to be disassembled with the
/// attribute.
///
///
/// A can be used to select files to disassemble.
/// To use a , the
/// attribute must be set. The file name of the output file will be equal
/// to the file name of the input file, but with extension ".il".
///
///
///
///
/// Disassembles helloworld.exe to helloworld.il.
///
///
///
/// ]]>
///
///
///
///
/// Disassembles a set of PE files into the specified directory.
///
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("ildasm")]
[ProgramLocation(LocationType.FrameworkSdkDir)]
public class IldasmTask : ExternalProgramBase {
#region Private Instance Fields
private const string _TargetExt = "il";
private bool _all;
private bool _bytes;
private bool _forceRebuild;
private bool _header;
private bool _lineNumbers;
private bool _noIL;
private bool _publicOnly;
private bool _quoteAllNames;
private bool _rawExceptionHandling;
private bool _source;
private bool _tokens;
private bool _unicode;
private bool _utf8;
private string _item;
private string _visibility;
private DirectoryInfo _toDir;
private FileInfo _inputFile;
private FileInfo _outputFile;
private FileSet _assemblies;
private string _options;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Specifies whether or not the disassembler should combine the
/// /HEADER, /BYTE, and /TOKENS options. The default
/// is .
///
///
/// if the disassembler should combine the
/// /HEADER, /BYTE, and /TOKENS options;
/// otherwise, . The default is
/// .
///
///
///
/// Corresponds to the /ALL flag.
///
///
[TaskAttribute("all")]
[BooleanValidator()]
public bool All {
get { return _all; }
set { _all = value; }
}
///
/// Specifies whether or not the disassembler should generate the
/// IL stream bytes (in hexadecimal notation) as instruction comments.
/// The default is .
///
///
/// if the IL stream bytes should be generated
/// as instruction comments; otherwise, . The
/// default is .
///
///
///
/// Corresponds to the /BYTE flag.
///
///
[TaskAttribute("bytes")]
[BooleanValidator()]
public bool Bytes {
get { return _bytes; }
set { _bytes = value; }
}
///
/// Instructs NAnt to rebuild the output file regardless of the file
/// timestamps. The default is .
///
///
/// if the output file should be rebuilt
/// regardless of its timestamps; otherwise .
/// The default is .
///
[TaskAttribute("rebuild")]
[BooleanValidator()]
public bool ForceRebuild {
get { return _forceRebuild; }
set { _forceRebuild = value; }
}
///
/// Specifies whether or not the disassembler should include PE header
/// information and runtime header information in the output. The default
/// is .
///
///
/// if PE header information and runtime header
/// information should be included in the output; otherwise,
/// . The default is .
///
///
///
/// Corresponds to the /HEADER flag.
///
///
[TaskAttribute("header")]
[BooleanValidator()]
public bool Header {
get { return _header; }
set { _header = value; }
}
///
/// Specifies the PE file to disassemble.
///
///
/// A that represents the PE file
/// to disassemble.
///
[TaskAttribute("input", Required=false)]
public FileInfo InputFile {
get { return _inputFile; }
set { _inputFile = value; }
}
///
/// Specifies whether or not the disassembler should include
/// references to original source lines. The default is .
///
///
/// if references to original source lines
/// should be included; otherwise, . The
/// default is .
///
///
///
/// Corresponds to the /LINENUM flag.
///
///
[TaskAttribute("linenumbers")]
[BooleanValidator()]
public bool LineNumbers {
get { return _lineNumbers; }
set { _lineNumbers = value; }
}
///
/// Specifies whether or not the disassembler should suppress ILASM
/// code output. The default is .
///
///
/// if ILASM code output should be suppresses;
/// otherwise, . The default is
/// .
///
///
///
/// Corresponds to the /NOIL flag.
///
///
[TaskAttribute("noil")]
[BooleanValidator()]
public bool NoIL {
get { return _noIL; }
set { _noIL = value; }
}
///
/// Specifies whether or not the disassembler should disassemble
/// public items only. This is a shortcut for ="pub".
/// The default is .
///
///
/// if only public items should be
/// disassembled; otherwise, . The default is
/// .
///
///
///
/// Corresponds to the /PUBONLY flag.
///
///
[TaskAttribute("publiconly")]
[BooleanValidator()]
public bool PublicOnly {
get { return _publicOnly; }
set { _publicOnly = value; }
}
///
/// Specifies whether or not the disassembler should enclose all names
/// in single quotation marks. By default, only names that don't match
/// the ILASM definition of a simple name are quoted. The default is
/// .
///
///
/// if all names should be enclosed in single
/// quotation marks; otherwise, . The default
/// is .
///
///
///
/// Corresponds to the /QUOTEALLNAMES flag.
///
///
[TaskAttribute("quoteallnames")]
[BooleanValidator()]
public bool QuoteAllNames {
get { return _quoteAllNames; }
set { _quoteAllNames = value; }
}
///
/// Specifies whether or not the disassembler should generate
/// structured exception handling clauses in canonical (label) form.
/// The default is .
///
///
/// if structured exception handling clauses
/// should be generated in canonical form; otherwise,
/// . The default is .
///
///
///
/// Corresponds to the /RAWEH flag.
///
///
[TaskAttribute("rawexceptionhandling")]
[BooleanValidator()]
public bool RawExceptionHandling {
get { return _rawExceptionHandling; }
set { _rawExceptionHandling = value; }
}
///
/// Specifies whether or not the disassembler should generate
/// original source lines as comments. The default is .
///
///
/// if original source lines should be
/// generated as comments; otherwise, .
/// The default is .
///
///
///
/// Corresponds to the /SOURCE flag.
///
///
[TaskAttribute("source")]
[BooleanValidator()]
public bool Source {
get { return _source; }
set { _source = value; }
}
///
/// Specifies whether or not the disassembler should generate metadata
/// token values as comments. The default is .
///
///
/// if metadata token values should be
/// generated as comments; otherwise, . The
/// default is .
///
///
///
/// Corresponds to the /TOKENS flag.
///
///
[TaskAttribute("tokens")]
[BooleanValidator()]
public bool Tokens {
get { return _tokens; }
set { _tokens = value; }
}
///
/// Specifies whether or not the disassembler should use the UNICODE
/// encoding when generating the output. The default is ANSI.
///
///
/// if the output should be generated using
/// the UNICODE encoding; otherwise, . The
/// default is .
///
///
///
/// Corresponds to the /UNICODE flag.
///
///
[TaskAttribute("unicode")]
[BooleanValidator()]
public bool Unicode {
get { return _unicode; }
set { _unicode = value; }
}
///
/// Specifies whether or not the disassembler should use the UTF-8
/// encoding when generating the output. The default is ANSI.
///
///
/// if the output should be generated using
/// the UTF-8 encoding; otherwise, . The
/// default is .
///
///
///
/// Corresponds to the /UTF8 flag.
///
///
[TaskAttribute("utf8")]
[BooleanValidator()]
public bool Utf8 {
get { return _utf8; }
set { _utf8 = value; }
}
///
/// Instructs the disassembler to disassemble the specified item only.
///
///
/// A that specifies the item to
/// disassemble.
///
///
///
/// Corresponds to the /ITEM flag.
///
///
[TaskAttribute("item", Required=false)]
[StringValidator(AllowEmpty=false)]
public string Item {
get { return _item; }
set { _item = value; }
}
///
/// Instructs the disassembler to disassemble only the items with the
/// specified visibility. Possible values are PUB, PRI,
/// FAM, ASM, FAA, FOA, PSC,
/// or any combination of them separated by +.
///
///
/// A that contains the visibility
/// suboptions.
///
///
///
/// Corresponds to the /VISIBILITY flag.
///
///
[TaskAttribute("visibility", Required=false)]
[StringValidator(AllowEmpty=false)]
public string Visibility {
get { return _visibility; }
set { _visibility = value; }
}
///
/// Specifies the name of the output file created by the disassembler.
///
///
/// A that represents the name of
/// the output file.
///
///
///
/// Corresponds to the /OUT flag.
///
///
[TaskAttribute("output", Required=false)]
public FileInfo OutputFile {
get { return _outputFile; }
set { _outputFile = value; }
}
///
/// Specifies the directory to which outputs will be stored.
///
///
/// A that represents the
/// directory to which outputs will be stored.
///
[TaskAttribute("todir", Required=false)]
public DirectoryInfo ToDirectory {
get { return _toDir; }
set { _toDir = value; }
}
///
/// Specifies a list of PE files to disassemble. To use a ,
/// the attribute must be specified.
///
///
/// A that represents the set
/// of PE files to disassemble.
///
[BuildElement("assemblies")]
public FileSet Assemblies {
get { return _assemblies; }
set { _assemblies = value; }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// The command-line arguments for the external program.
///
///
/// Overridden to ensure the <arg> elements would not be exposed
/// to build authors.
///
public override ArgumentCollection Arguments {
get { return base.Arguments; }
}
///
/// Gets the command-line arguments for the external program.
///
///
/// A that contains the command-line
/// arguments for the external program.
///
public override string ProgramArguments {
get { return _options; }
}
///
/// Checks whether the task is initialized with valid attributes.
///
protected override void Initialize() {
if (ToDirectory == null && Assemblies != null && Assemblies.Includes.Count > 0) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3001")), Location);
}
if (InputFile != null && Assemblies != null && Assemblies.Includes.Count > 0) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3002")), Location);
}
if (OutputFile == null && ToDirectory == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3003")), Location);
}
if (OutputFile != null && ToDirectory != null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3004")), Location);
}
}
///
/// Disassembles the PE file(s).
///
protected override void ExecuteTask() {
// disassemble a single PE file
if (InputFile != null) {
DisassemblyFile(InputFile);
} else {
foreach (string inputFile in Assemblies.FileNames) {
DisassemblyFile(new FileInfo(inputFile));
}
}
}
#endregion Override implementation of ExternalProgramBase
#region Private Instance Methods
///
/// Disassembles the specified PE file.
///
/// The PE file to disassemble.
private void DisassemblyFile(FileInfo inputFile) {
// verify if input file actually exists
if (!inputFile.Exists) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3005"), inputFile.FullName), Location);
}
// determine output file corresponding with PE file
FileInfo outputFile = GetOutputFile(inputFile);
// only actually perform disassembly if necessary
if (NeedsDisassembling(inputFile, outputFile)) {
Log(Level.Info, ResourceUtils.GetString("String_Disassembling"),
inputFile.FullName, outputFile.FullName);
// ensure output directory exists
if (!outputFile.Directory.Exists) {
outputFile.Directory.Create();
}
// set command-line arguments for the disassembler
WriteOptions(inputFile, outputFile);
// call base class to do the work
base.ExecuteTask();
}
}
///
/// Determines the full path and extension for the output file.
///
///
/// A that represents the PE file
/// file for which the corresponding output file should be determined.
///
///
/// A that represents the full path
/// for the output file.
///
/// The path of the output file could not be determined.
private FileInfo GetOutputFile(FileInfo inputFile) {
FileInfo outputFile;
if (OutputFile != null) {
outputFile = new FileInfo(OutputFile.FullName);
} else if (ToDirectory != null) {
outputFile = new FileInfo(Path.Combine(ToDirectory.FullName, inputFile.Name));
outputFile = new FileInfo(Path.ChangeExtension(outputFile.FullName, _TargetExt));
} else {
// we should never actually get here (if the checks in
// Initialize have been executed
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3006"), inputFile.FullName), Location);
}
return outputFile;
}
///
/// Writes the disassembler options.
///
private void WriteOptions(FileInfo inputFile, FileInfo outputFile) {
using (StringWriter writer = new StringWriter()) {
// always direct the output to console
WriteOption(writer, "TEXT");
WriteOption(writer, "NOBAR");
if (All) {
WriteOption(writer, "ALL");
}
if (Bytes) {
WriteOption(writer, "BYTES");
}
if (Header) {
WriteOption(writer, "HEADER");
}
if (LineNumbers) {
WriteOption(writer, "LINENUM");
}
if (NoIL) {
WriteOption(writer, "NOIL");
}
if (PublicOnly) {
WriteOption(writer, "PUBONLY");
}
if (QuoteAllNames) {
WriteOption(writer, "QUOTEALLNAMES");
}
if (RawExceptionHandling) {
WriteOption(writer, "RAWEH");
}
if (Source) {
WriteOption(writer, "SOURCE");
}
if (Tokens) {
WriteOption(writer, "TOKENS");
}
if (Unicode) {
WriteOption(writer, "UNICODE");
}
if (Utf8) {
WriteOption(writer, "UTF8");
}
if (Item != null) {
WriteOption(writer, "ITEM", Item);
}
if (Visibility != null) {
WriteOption(writer, "VISIBILITY", Visibility.ToUpper());
}
// specifiy path of output file
WriteOption(writer, "OUT", outputFile.FullName);
// specify path of PE file to disassembly
writer.Write(" \"" + inputFile.FullName + "\" ");
_options = writer.ToString();
// close the StringWriter and the underlying stream
writer.Close();
}
}
///
/// Writes an option using the default output format.
///
///
/// The to which the disassembler options
/// should be written.
///
///
/// A that contains the name of the
/// option which should be passed to the disassembler.
///
private void WriteOption(StringWriter writer, string name) {
writer.Write("/{0} ", name);
}
///
/// Writes an option and its value using the default output format.
///
///
/// The to which the disassembler options
/// should be written.
///
///
/// A that contains the name of the
/// option which should be passed to the disassembler.
///
///
/// A that contains the value of the
/// option which should be passed to the disassembler.
///
private void WriteOption(StringWriter writer, string name, string arg) {
// always quote arguments
writer.Write("\"/{0}={1}\" ", name, arg);
}
///
/// Determines whether or not disassembling is needed.
///
///
/// if disassembling is needed; otherwise,
/// .
///
private bool NeedsDisassembling(FileInfo inputFile, FileInfo outputFile) {
if (ForceRebuild) {
Log(Level.Verbose, ResourceUtils.GetString("String_RebuildAttributeSetToTrue"));
return true;
}
// check if output file already exists
if (!outputFile.Exists) {
Log(Level.Verbose, ResourceUtils.GetString("String_OutputFileDoesNotExist"),
outputFile.FullName);
return true;
}
// check if the source assembly has been updated
string fileName = FileSet.FindMoreRecentLastWriteTime(
inputFile.FullName, outputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
// no need to disassembly the input file
return false;
}
#endregion Private Instance Methods
}
}
nant-0.92-rc1/src/NAnt.MSNet/Tasks/ServiceControllerTask.cs 0000644 0001750 0001750 00000036413 11757302274 023357 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gert Driesen
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
// Giuseppe Greco (giuseppe.greco@agamura.com)
using System;
using System.ComponentModel;
using System.Globalization;
using System.ServiceProcess;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Util;
namespace NAnt.MSNet.Tasks {
///
/// Allows a Windows service to be controlled.
///
///
/// Starts the World Wide Web Publishing Service on the local computer.
///
///
/// ]]>
///
///
///
/// Stops the Alerter service on computer 'MOTHER'.
///
///
/// ]]>
///
///
[TaskName("servicecontroller")]
public class ServiceControllerTask : Task {
///
/// Defines the actions that can be performed on a service.
///
public enum ActionType {
///
/// Starts a service.
///
Start,
///
/// Stops a service.
///
Stop,
///
/// Restarts a service.
///
Restart,
///
/// Pauses a running service.
///
Pause,
///
/// Continues a paused service.
///
Continue
}
#region Public Instance Constructors
///
/// Initializes a new instance of the
/// class.
///
public ServiceControllerTask() {
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// The name of the service that should be controlled.
///
[TaskAttribute("service", Required=true)]
[StringValidator(AllowEmpty=false)]
public string ServiceName {
get { return _serviceName; }
set { _serviceName = StringUtils.ConvertEmptyToNull(value); }
}
///
/// The name of the computer on which the service resides. The default
/// is the local computer.
///
[TaskAttribute("machine")]
public string MachineName {
get { return (_machineName == null) ? "." : _machineName; }
set { _machineName = StringUtils.ConvertEmptyToNull(value); }
}
///
/// The action that should be performed on the service.
///
[TaskAttribute("action", Required=true)]
public ActionType Action {
get { return _action; }
set { _action = value; }
}
///
/// The time, in milliseconds, the task will wait for the service to
/// reach the desired status. The default is 5000 milliseconds.
///
[TaskAttribute("timeout", Required=false)]
public double Timeout {
get { return _timeout; }
set { _timeout = value; }
}
#endregion Public Instance Properties
#region Override implementation of Task
///
/// Peforms actions on the service in order to reach the desired status.
///
protected override void ExecuteTask() {
// get handle to service
using (ServiceController serviceController = new ServiceController(ServiceName, MachineName)) {
// determine desired status
ServiceControllerStatus desiredStatus = DetermineDesiredStatus();
try {
// determine current status, this is also verifies if the service
// is available
ServiceControllerStatus currentStatus = serviceController.Status;
} catch (Exception ex) {
throw new BuildException(ex.Message, Location, ex.InnerException);
}
// we only need to take action if the service status differs from
// the desired status or if the service should be restarted
if (serviceController.Status != desiredStatus || Action == ActionType.Restart) {
switch (Action) {
case ActionType.Start:
StartService(serviceController);
break;
case ActionType.Pause:
PauseService(serviceController);
break;
case ActionType.Continue:
ContinueService(serviceController);
break;
case ActionType.Stop:
StopService(serviceController);
break;
case ActionType.Restart:
RestartService(serviceController);
break;
}
// refresh current service status
serviceController.Refresh();
}
}
}
#endregion Override implementation of Task
#region Private Instance Methods
///
/// Determines the desired status of the service based on the action
/// that should be performed on it.
///
///
/// The that should be reached
/// in order for the to be considered successful.
///
private ServiceControllerStatus DetermineDesiredStatus() {
switch (Action) {
case ActionType.Stop:
return ServiceControllerStatus.Stopped;
case ActionType.Pause:
return ServiceControllerStatus.Paused;
default:
return ServiceControllerStatus.Running;
}
}
///
/// Starts the service identified by and
/// .
///
/// instance for controlling the service identified by and .
private void StartService(ServiceController serviceController) {
try {
if (serviceController.Status == ServiceControllerStatus.Paused) {
serviceController.Continue();
} else {
serviceController.Start();
}
// wait until service is running or timeout expired
serviceController.WaitForStatus(ServiceControllerStatus.Running,
TimeSpan.FromMilliseconds(Timeout));
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3007"), ServiceName, MachineName), Location, ex);
}
}
///
/// Stops the service identified by and
/// .
///
/// instance for controlling the service identified by and .
private void StopService(ServiceController serviceController) {
try {
if (serviceController.CanStop) {
serviceController.Stop();
} else {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3008"), ServiceName, MachineName), Location);
}
// wait until service is stopped or timeout expired
serviceController.WaitForStatus(ServiceControllerStatus.Stopped,
TimeSpan.FromMilliseconds(Timeout));
} catch (BuildException ex) {
// rethrow exception
throw ex;
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3008"), ServiceName, MachineName), Location, ex);
}
}
///
/// Restarts the service identified by and
/// .
///
/// instance for controlling the service identified by and .
private void RestartService(ServiceController serviceController) {
// only stop service if its not already stopped
if (serviceController.Status != ServiceControllerStatus.Stopped) {
StopService(serviceController);
}
// start the service
StartService(serviceController);
}
///
/// Pauses the service identified by and
/// .
///
/// instance for controlling the service identified by and .
private void PauseService(ServiceController serviceController) {
try {
if (serviceController.Status == ServiceControllerStatus.Running) {
if (serviceController.CanPauseAndContinue) {
if (serviceController.Status != ServiceControllerStatus.Running) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3010"), ServiceName, MachineName),
Location);
} else {
serviceController.Pause();
}
} else {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3011"), ServiceName, MachineName),
Location);
}
} else {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3010"), ServiceName, MachineName),
Location);
}
// wait until service is paused or timeout expired
serviceController.WaitForStatus(ServiceControllerStatus.Paused,
TimeSpan.FromMilliseconds(Timeout));
} catch (BuildException ex) {
// rethrow exception
throw ex;
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3009"), ServiceName, MachineName),
Location, ex);
}
}
///
/// Continues the service identified by and
/// .
///
/// instance for controlling the service identified by and .
private void ContinueService(ServiceController serviceController) {
try {
if (serviceController.Status == ServiceControllerStatus.Paused) {
if (serviceController.CanPauseAndContinue) {
if (serviceController.Status == ServiceControllerStatus.Paused) {
serviceController.Continue();
} else if (serviceController.Status != ServiceControllerStatus.Running) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3013"), ServiceName, MachineName),
Location);
} else {
// do nothing as service is already running
}
} else {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3014"), ServiceName, MachineName),
Location);
}
} else {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3015"), ServiceName, MachineName),
Location);
}
// wait until service is running or timeout expired
serviceController.WaitForStatus(ServiceControllerStatus.Running,
TimeSpan.FromMilliseconds(Timeout));
} catch (BuildException ex) {
// rethrow exception
throw ex;
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA3012"), ServiceName, MachineName),
Location, ex);
}
}
#endregion Private Instance Methods
#region Private Instance Fields
///
/// Holds the name of the service that should be controlled.
///
private string _serviceName;
///
/// Holds the name of the computer on which the service resides.
///
private string _machineName;
///
/// Holds the action that should be performed on the service.
///
private ActionType _action;
///
/// Holds the time, in milliseconds, the task will wait for a service
/// to reach the desired status.
///
private double _timeout = 5000;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.MSNet/NAnt.MSNet.csproj 0000644 0001750 0001750 00000010173 11757302274 020516 0 ustar jtaylor jtaylor
DebugAnyCPU2.0{ED13C268-36DE-49CE-B347-C2BE03F814B9}NAnt.MSNetNAnt.MSNetTasksLibraryOnSuccessfulBuildfalse8.0.50727v2.02.0publish\trueDiskfalseForeground7Daysfalsefalsetrue01.0.0.%2afalsefalsetruetruefullfalse4..\..\build\Debug\AllRules.rulesetTRACE;DEBUG..\..\build\Debug\NAnt.MSNetTasks.xmltruepdbonlytrue4..\..\build\Release\AllRules.rulesetTRACE..\..\build\Release\NAnt.MSNetTasks.xml
CommonAssemblyInfo.cs
False.NET Framework 3.5 SP1 Client ProfilefalseFalse.NET Framework 3.5 SP1trueFalseWindows Installer 3.1true{8F5F8375-4097-4952-B860-784EB9961ABE}NAnt.Core nant-0.92-rc1/src/NDoc.Documenter.NAnt/ 0000755 0001750 0001750 00000000000 11757310030 017373 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NDoc.Documenter.NAnt/NAntDocumenter.cs 0000644 0001750 0001750 00000047606 11757302275 022641 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Ian MacLean (ian@maclean.ms)
// Gerry Shaw (gerry_shaw@yahoo.com)
// Gert Driesen (drieseng@users.sourceforge.net)
// Scott Hernandez (ScottHernandez_hotmail_com)
using System;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Text;
using System.Xml;
using System.Xml.Xsl;
using NDoc.Core;
using NDoc.Core.Reflection;
using NAnt.Core;
using NAnt.Core.Attributes;
namespace NDoc.Documenter.NAnt {
///
/// NDoc Documenter for building custom NAnt User documentation.
///
public class NAntDocumenter : BaseReflectionDocumenter {
#region Private Instance Fields
private XslTransform _xsltTaskIndex;
private XslTransform _xsltTypeIndex;
private XslTransform _xsltFunctionIndex;
private XslTransform _xsltFilterIndex;
private XslTransform _xsltTypeDoc;
private XslTransform _xsltFunctionDoc;
private XmlDocument _xmlDocumentation;
private string _resourceDirectory;
private StringDictionary _writtenFiles = new StringDictionary();
#endregion Private Instance Fields
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public NAntDocumenter() : base("NAnt") {
Clear();
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets the documenter's output directory.
///
///
/// The documenter's output directory.
///
public string OutputDirectory {
get {
return ((NAntDocumenterConfig) Config).OutputDirectory;
}
}
///
/// Gets or sets the root namespace to document.
///
///
/// The root namespace to document, or a empty
/// if no restriction should be set on the namespace to document.
///
public string NamespaceFilter {
get {
return ((NAntDocumenterConfig) Config).NamespaceFilter;
}
}
///
/// Gets the name of the product for which documentation should be
/// generated.
///
///
/// The name of the product for which documentation should be
/// generated.
///
public string ProductName {
get {
return ((NAntDocumenterConfig) Config).ProductName;
}
}
///
/// Gets the version of the product for which documentation should be
/// generated.
///
///
/// The version of the product for which documentation should be
/// generated.
///
public string ProductVersion {
get {
return ((NAntDocumenterConfig) Config).ProductVersion;
}
}
///
/// Gets the URL of the website of the product for which documentation
/// should be generated.
///
///
/// The URL of the website of the product for which documentation should
/// be generated.
///
public string ProductUrl {
get {
return ((NAntDocumenterConfig) Config).ProductUrl;
}
}
#endregion Public Instance Properties
#region Override implementation of IDocumenter
///
/// Gets the documenter's main output file.
///
///
/// The documenter's main output file.
///
public override string MainOutputFile {
get { return ""; }
}
///
/// Resets the documenter to a clean state.
///
public override void Clear() {
Config = new NAntDocumenterConfig();
}
///
/// Builds the documentation.
///
public override void Build(NDoc.Core.Project project) {
int buildStepProgress = 0;
OnDocBuildingStep(buildStepProgress, "Initializing...");
_resourceDirectory = Path.Combine(Path.Combine(Environment.GetFolderPath(
Environment.SpecialFolder.ApplicationData), "NDoc"), "NAnt");
// get assembly in which documenter is defined
Assembly assembly = this.GetType().Module.Assembly;
// write xslt files to resource directory
EmbeddedResources.WriteEmbeddedResources(assembly, "Documenter.xslt",
Path.Combine(_resourceDirectory, "xslt"));
// create the html output directories
try {
Directory.CreateDirectory(OutputDirectory);
Directory.CreateDirectory(Path.Combine(OutputDirectory, "elements"));
Directory.CreateDirectory(Path.Combine(OutputDirectory, "functions"));
Directory.CreateDirectory(Path.Combine(OutputDirectory, "types"));
Directory.CreateDirectory(Path.Combine(OutputDirectory, "tasks"));
Directory.CreateDirectory(Path.Combine(OutputDirectory, "enums"));
Directory.CreateDirectory(Path.Combine(OutputDirectory, "filters"));
} catch (Exception ex) {
throw new DocumenterException("The output directories could not"
+ " be created.", ex);
}
buildStepProgress += 10;
OnDocBuildingStep(buildStepProgress, "Merging XML documentation...");
// load the stylesheets that will convert the master xml into html pages
MakeTransforms();
// will hold the file name containing the NDoc generated XML
string tempFile = null;
try {
// determine temporary file name
tempFile = Path.GetTempFileName();
// create the master XML document
MakeXmlFile(project, tempFile);
// create a xml document that will be transformed using xslt
using (FileStream fs = new FileStream(tempFile, FileMode.Open, FileAccess.Read, FileShare.Read)) {
_xmlDocumentation = new XmlDocument();
_xmlDocumentation.Load(fs);
}
} finally {
// ensure temporary file is removed
if (tempFile != null) {
File.Delete(tempFile);
}
}
// build the file mapping
buildStepProgress += 15;
OnDocBuildingStep(buildStepProgress, "Building mapping...");
// create arguments for nant index page transform
XsltArgumentList indexArguments = CreateXsltArgumentList();
// add extension object for NAnt utilities
NAntXsltUtilities indexUtilities = NAntXsltUtilities.CreateInstance(
_xmlDocumentation, (NAntDocumenterConfig) Config);
// add extension object to Xslt arguments
indexArguments.AddExtensionObject("urn:NAntUtil", indexUtilities);
buildStepProgress += 15;
OnDocBuildingStep(buildStepProgress, "Creating Task Index Page...");
// transform nant task index page transform
TransformAndWriteResult(_xsltTaskIndex, indexArguments, "tasks/index.html");
buildStepProgress += 10;
OnDocBuildingStep(buildStepProgress, "Creating Type Index Page...");
// transform nant type index page transform
TransformAndWriteResult(_xsltTypeIndex, indexArguments, "types/index.html");
buildStepProgress += 10;
OnDocBuildingStep(buildStepProgress, "Creating Filter Index Page...");
// transform nant type index page transform
TransformAndWriteResult(_xsltFilterIndex, indexArguments, "filters/index.html");
OnDocBuildingStep(buildStepProgress, "Creating Function Index Page...");
// transform nant function index page transform
TransformAndWriteResult(_xsltFunctionIndex, indexArguments, "functions/index.html");
buildStepProgress += 10;
OnDocBuildingStep(buildStepProgress, "Generating Task Documents...");
// generate a page for each marked task
XmlNodeList typeNodes = _xmlDocumentation.SelectNodes("//class[starts-with(substring(@id, 3, string-length(@id) - 2), '" + NamespaceFilter + "')]");
foreach (XmlNode typeNode in typeNodes) {
ElementDocType elementDocType = indexUtilities.GetElementDocType(typeNode);
DocumentType(typeNode, elementDocType, indexUtilities);
}
OnDocBuildingStep(buildStepProgress, "Generating Function Documents...");
// generate a page for each function - TODO - change the XPath expression to select more functions
XmlNodeList functionNodes = _xmlDocumentation.SelectNodes("//method[attribute/@name = 'NAnt.Core.Attributes.FunctionAttribute' and ancestor::class[starts-with(substring(@id, 3, string-length(@id) - 2), '" + NamespaceFilter + "')]]");
foreach (XmlElement function in functionNodes) {
DocumentFunction(function, indexUtilities);
}
OnDocBuildingStep(100, "Complete");
}
#endregion Override implementation of IDocumenter
#region Private Instance Methods
private void DocumentType(XmlNode typeNode, ElementDocType docType, NAntXsltUtilities utilities) {
if (typeNode == null) {
throw new ArgumentNullException("typeNode");
}
if (docType == ElementDocType.None || docType == ElementDocType.FunctionSet) {
// we don't need to document this type
return;
}
string classID = typeNode.Attributes["id"].Value;
if (!classID.Substring(2).StartsWith(NamespaceFilter)) {
// we don't need to types in this namespace
return;
}
string filename = utilities.GetFileNameForType(typeNode, false);
if (filename == null) {
// we should never get here, but just in case ...
return;
}
if (_writtenFiles.ContainsValue(classID)) {
return;
} else {
_writtenFiles.Add(filename, classID);
}
// create arguments for nant task page transform (valid args are class-id, refType, imagePath, relPathAdjust)
XsltArgumentList arguments = CreateXsltArgumentList();
arguments.AddParam("class-id", String.Empty, classID);
string refTypeString;
switch (docType) {
case ElementDocType.DataTypeElement:
refTypeString = "Type";
break;
case ElementDocType.Element:
refTypeString = "Element";
break;
case ElementDocType.Task:
refTypeString = "Task";
break;
case ElementDocType.Enum:
refTypeString = "Enum";
break;
case ElementDocType.Filter:
refTypeString = "Filter";
break;
default:
refTypeString = "Other?";
break;
}
arguments.AddParam("refType", string.Empty, refTypeString);
// add extension object to Xslt arguments
arguments.AddExtensionObject("urn:NAntUtil", utilities);
// Process all sub-elements and generate docs for them. :)
// Just look for properties with attributes to narrow down the foreach loop.
// (This is a restriction of NAnt.Core.Attributes.BuildElementAttribute)
foreach (XmlNode propertyNode in typeNode.SelectNodes("property[attribute]")) {
//get the xml element
string elementName = utilities.GetElementNameForProperty(propertyNode);
if (elementName != null) {
// try to get attribute info if it is an array/collection.
// strip the array brakets "[]" to get the type
string elementType = "T:" + propertyNode.Attributes["type"].Value.Replace("[]","");
// check whether property is an element array
XmlNode nestedElementNode = propertyNode.SelectSingleNode("attribute[@name='" + typeof(BuildElementArrayAttribute).FullName + "']");
if (nestedElementNode == null) {
// check whether property is an element collection
nestedElementNode = propertyNode.SelectSingleNode("attribute[@name='" + typeof(BuildElementCollectionAttribute).FullName + "']");
}
// if property is either array or collection type element
if (nestedElementNode != null) {
// select the item type in the collection
XmlAttribute elementTypeAttribute = _xmlDocumentation.SelectSingleNode("//class[@id='" + elementType + "']/method[@name='Add']/parameter/@type") as XmlAttribute;
if (elementTypeAttribute != null) {
// get type of collection elements
elementType = "T:" + elementTypeAttribute.Value;
}
// if it contains a ElementType attribute then it is an array or collection
// if it is a collection, then we care about the child type.
XmlNode explicitElementType = propertyNode.SelectSingleNode("attribute/property[@ElementType]");
if (explicitElementType != null) {
// ndoc is inconsistent about how classes are named.
elementType = explicitElementType.Attributes["value"].Value.Replace("+",".");
}
}
XmlNode elementTypeNode = utilities.GetTypeNodeByID(elementType);
if (elementTypeNode != null) {
ElementDocType elementDocType = utilities.GetElementDocType(elementTypeNode);
if (elementDocType != ElementDocType.None) {
DocumentType(elementTypeNode, elementDocType,
utilities);
}
}
}
}
// create the page
TransformAndWriteResult(_xsltTypeDoc, arguments, filename);
}
private void DocumentFunction(XmlElement functionElement, NAntXsltUtilities utilities) {
if (functionElement == null) {
throw new ArgumentNullException("functionElement");
}
string methodID = functionElement.GetAttribute("id");
string filename = utilities.GetFileNameForFunction(functionElement, false);
XsltArgumentList arguments = CreateXsltArgumentList();
arguments.AddParam("method-id", string.Empty, methodID);
arguments.AddParam("refType", string.Empty, "Function");
arguments.AddParam("functionName", string.Empty, functionElement.GetAttribute("name"));
// add extension object to Xslt arguments
arguments.AddExtensionObject("urn:NAntUtil", utilities);
// document parameter types
foreach (XmlAttribute paramTypeAttribute in functionElement.SelectNodes("parameter/@type")) {
string paramType = "T:" + paramTypeAttribute.Value;
XmlNode typeNode = utilities.GetTypeNodeByID(paramType);
if (typeNode != null) {
ElementDocType paramDocType = utilities.GetElementDocType(typeNode);
if (paramDocType != ElementDocType.None) {
DocumentType(typeNode, paramDocType, utilities);
}
}
}
// document return type
XmlAttribute returnTypeAttribute = functionElement.Attributes["returnType"];
if (returnTypeAttribute != null) {
string returnType = "T:" + returnTypeAttribute.Value;
XmlNode returnTypeNode = utilities.GetTypeNodeByID(returnType);
if (returnTypeNode != null) {
ElementDocType returnDocType = utilities.GetElementDocType(returnTypeNode);
if (returnDocType != ElementDocType.None) {
DocumentType(returnTypeNode, returnDocType, utilities);
}
}
}
// create the page
TransformAndWriteResult(_xsltFunctionDoc, arguments, filename);
}
private void MakeTransforms() {
OnDocBuildingProgress(0);
_xsltTaskIndex = new XslTransform();
_xsltTypeIndex = new XslTransform();
_xsltFunctionIndex = new XslTransform();
_xsltFilterIndex = new XslTransform();
_xsltTypeDoc = new XslTransform();
_xsltFunctionDoc = new XslTransform();
MakeTransform(_xsltTaskIndex, "task-index.xslt");
OnDocBuildingProgress(20);
MakeTransform(_xsltTypeIndex, "type-index.xslt");
OnDocBuildingProgress(40);
MakeTransform(_xsltFilterIndex, "filter-index.xslt");
OnDocBuildingProgress(50);
MakeTransform(_xsltFunctionIndex, "function-index.xslt");
OnDocBuildingProgress(60);
MakeTransform(_xsltTypeDoc, "type-doc.xslt");
OnDocBuildingProgress(80);
MakeTransform(_xsltFunctionDoc, "function-doc.xslt");
OnDocBuildingProgress(100);
}
private void MakeTransform(XslTransform transform, string fileName) {
transform.Load(Path.Combine(Path.Combine(_resourceDirectory, "xslt"),
fileName));
}
private XsltArgumentList CreateXsltArgumentList() {
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("productName", string.Empty, ProductName);
arguments.AddParam("productVersion", string.Empty, ProductVersion);
arguments.AddParam("productUrl", string.Empty, ProductUrl);
return arguments;
}
private void TransformAndWriteResult(XslTransform transform, XsltArgumentList arguments, string filename) {
string path = Path.Combine(OutputDirectory, filename);
using (StreamWriter writer = new StreamWriter(path, false, Encoding.UTF8)) {
transform.Transform(_xmlDocumentation, arguments, writer);
}
}
#endregion Private Instance Methods
}
public enum ElementDocType {
None = 0,
Task = 1,
DataTypeElement = 2,
Element = 3,
Enum = 4,
Filter = 5,
FunctionSet = 6
}
}
nant-0.92-rc1/src/NDoc.Documenter.NAnt/NAntDocumenterConfig.cs 0000644 0001750 0001750 00000015404 11757302275 023756 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Ian MacLean (ian@maclean.ms)
// Gerry Shaw (gerry_shaw@yahoo.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.ComponentModel;
using System.Globalization;
using System.Xml;
using NDoc.Core;
using NDoc.Core.Reflection;
namespace NDoc.Documenter.NAnt {
///
/// NDoc configuration class for .
///
public class NAntDocumenterConfig : BaseReflectionDocumenterConfig {
#region Private Instance Fields
private string _outputDirectory = @"doc/help/tasks";
private bool _sdkLinksOnWeb;
private string _productName = "NAnt";
private string _productVersion = "";
private string _productUrl = "";
private string _nantBaseUri = "";
private string _namespaceFilter = "";
#endregion Private Instance Fields
#region Public Instance Constructors
///
/// Initializes a new instance of the
/// class.
///
public NAntDocumenterConfig() : base("NAnt") {
// set reasonable ndoc defaults so we don't have to do this in the build file
CopyrightText = String.Format(CultureInfo.InvariantCulture, "Copyright (C) 2001-{0} Gerry Shaw", DateTime.Now.Year);
CopyrightHref = "http://nant.sourceforge.net/";
ShowMissingParams = false;
ShowMissingRemarks = false;
ShowMissingReturns = false;
ShowMissingSummaries = false;
ShowMissingValues = false;
DocumentAttributes = true;
DocumentEmptyNamespaces = false;
DocumentInternals = false;
DocumentPrivates = false;
DocumentProtected = true;
SkipNamespacesWithoutSummaries = false;
EditorBrowsableFilter = EditorBrowsableFilterLevel.HideAdvanced;
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets or sets the output directory.
///
///
/// The output directory.
///
[Category("Documentation Main Settings")]
[Description("The path to the output directory where the generated docs will be placed.")]
public string OutputDirectory {
get { return _outputDirectory; }
set {
_outputDirectory = value;
SetDirty();
}
}
///
/// Gets or sets a value indicating whether .NET Framework SDK links
/// should point to the online MSDN library.
///
[Category("Documentation Main Settings")]
[Description("Turning this flag on will point all SDK links to the online MSDN library")]
[DefaultValue(false)]
public bool SdkLinksOnWeb {
get { return _sdkLinksOnWeb; }
set {
_sdkLinksOnWeb= value;
SetDirty();
}
}
///
/// Gets or sets the name of the product for which documentation
/// should be generated.
///
///
/// The name of the product for which documentation should be
/// generated. The default is "NAnt".
///
[Category("Output")]
[Description("The name of the product for which documentation should be generated.")]
[DefaultValue("NAnt")]
public string ProductName {
get { return _productName; }
set {
_productName = value;
SetDirty();
}
}
///
/// Gets or sets the version of the product for which documentation
/// should be generated.
///
///
/// The version of the product for which documentation should be
/// generated.
///
[Category("Output")]
[Description("The version of the product for which documentation should be generated.")]
[DefaultValue("")]
public string ProductVersion {
get { return _productVersion; }
set {
_productVersion = value;
SetDirty();
}
}
///
/// Gets or sets the URL of product website.
///
///
/// The URL of the website of the product for which documentation should
/// be generated.
///
[Category("Output")]
[Description("The URL of the website of the product for which documentation should be generated.")]
[DefaultValue("")]
public string ProductUrl {
get { return _productUrl; }
set {
_productUrl = value;
SetDirty();
}
}
///
/// Gets or sets the base URI for linking to NAnt docs.
///
///
/// The base URI for linking to NAnt docs.
///
[Category("Output")]
[Description("The base URI for linking to NAnt docs.")]
public string NAntBaseUri {
get { return _nantBaseUri; }
set {
_nantBaseUri = value;
SetDirty();
}
}
///
/// Gets or sets the root namespace to document.
///
///
/// The root namespace to document, or a empty
/// if no restriction should be set on the namespace to document.
///
[Category("Output")]
[Description("The root namespace to document, or an empty string to document all namespaces.")]
public string NamespaceFilter {
get { return _namespaceFilter; }
set {
_namespaceFilter = value;
SetDirty();
}
}
#endregion Public Instance Properties
}
}
nant-0.92-rc1/src/NDoc.Documenter.NAnt/AssemblyInfo.cs 0000644 0001750 0001750 00000002254 11757302275 022334 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Ian MaceLean (ian@maclean.ms)
// Gert Driesen (drieseng@users.sourceforge.net)
using System.Reflection;
// This will not compile with Visual Studio. If you want to build a signed
// executable use the NAnt build file. To build under Visual Studio just
// exclude this file from the build.
[assembly: AssemblyDelaySign(false)]
//[assembly: AssemblyKeyFile(@"..\NAnt.key")]
[assembly: AssemblyKeyName("")]
nant-0.92-rc1/src/NDoc.Documenter.NAnt/NAntXsltUtilities.cs 0000644 0001750 0001750 00000077715 11757302275 023366 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
// Scott Hernandez ScottHernandez_At_hOtmail.d.o.t.com
using System.Collections;
using System.Collections.Specialized;
using System.Text;
using System.Web;
using System.Xml;
using System.Xml.XPath;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Filters;
using NDoc.Core.Reflection;
namespace NDoc.Documenter.NAnt {
///
/// Provides an extension object for the XSLT transformations.
///
public class NAntXsltUtilities {
#region Private Instance Fields
private string _sdkDocBaseUrl;
private string _sdkDocExt;
private StringDictionary _elementNames = new StringDictionary();
private XmlDocument _doc;
private NAntDocumenterConfig _config;
#endregion Private Instance Fields
#region Private Static Fields
private const string SdkDoc10BaseUrl = "ms-help://MS.NETFrameworkSDK/cpref/html/frlrf";
private const string SdkDoc11BaseUrl = "ms-help://MS.NETFrameworkSDKv1.1/cpref/html/frlrf";
private const string SdkDocPageExt = ".htm";
private const string MsdnOnlineSdkBaseUrl = "http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrf";
private const string MsdnOnlineSdkPageExt = ".asp";
private const string SystemPrefix = "System.";
private const string MicrosoftWin32Prefix = "Microsoft.Win32.";
private static ArrayList Instances = new ArrayList(3);
#endregion Private Static Fields
#region Public Instance Constructors
///
/// Initializes a new instance of the
/// class.
///
private NAntXsltUtilities(XmlDocument doc, NAntDocumenterConfig config) {
_doc = doc;
_config = config;
if (config.SdkLinksOnWeb) {
_sdkDocBaseUrl = MsdnOnlineSdkBaseUrl;
_sdkDocExt = MsdnOnlineSdkPageExt;
} else {
switch (config.SdkDocVersion) {
case SdkVersion.SDK_v1_0:
_sdkDocBaseUrl = SdkDoc10BaseUrl;
_sdkDocExt = SdkDocPageExt;
break;
case SdkVersion.SDK_v1_1:
_sdkDocBaseUrl = SdkDoc11BaseUrl;
_sdkDocExt = SdkDocPageExt;
break;
}
}
// create a list of element names by id
XmlNodeList types = Document.SelectNodes("//class");
foreach (XmlElement typeNode in types) {
string typeId = typeNode.Attributes["id"].Value;
_elementNames[typeId] = GetElementNameForType(typeNode);
XmlNodeList members = typeNode.SelectNodes("*[@id]");
foreach (XmlElement memberNode in members) {
string id = memberNode.Attributes["id"].Value;
switch (memberNode.Name) {
case "constructor":
_elementNames[id] = _elementNames[typeId];
break;
case "field":
_elementNames[id] = memberNode.Attributes["name"].Value;
break;
case "property":
_elementNames[id] = GetElementNameForProperty(memberNode);
break;
case "method":
_elementNames[id] = GetElementNameForMethod(memberNode);
break;
case "operator":
_elementNames[id] = memberNode.Attributes["name"].Value;
break;
case "event":
_elementNames[id] = memberNode.Attributes["name"].Value;
break;
}
}
}
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets the base url for links to system types.
///
///
/// The base url for links to system types.
///
public string SdkDocBaseUrl {
get { return _sdkDocBaseUrl; }
}
///
/// Gets the page file extension for links to system types.
///
public string SdkDocExt {
get { return _sdkDocExt; }
}
#endregion Public Instance Properties
#region Private Instance Properties
private XmlDocument Document {
get { return _doc; }
}
private NAntDocumenterConfig Config {
get { return _config; }
}
#endregion Private Instance Properties
#region Public Instance Methods
///
/// Gets the root namespace to document.
///
///
/// The root namespace to document, or a empty
/// if no restriction should be set on the namespace to document.
///
public string GetNamespaceFilter() {
return Config.NamespaceFilter;
}
///
/// Searches the document for the <class> node with the
/// given id.
///
/// Type.FullName of class to return
///
/// The <class> node with the given id, or
/// if the node does not exist.
///
public XPathNodeIterator GetClassNode(string id) {
if (!id.StartsWith("T:")) {
id = "T:" + id;
}
XmlNode typeNode = Document.SelectSingleNode("//class[@id='" + id + "']");
if (typeNode == null) {
return null;
}
return typeNode.CreateNavigator().Select(".");
}
///
/// Returns an href for a cref.
///
/// The cref for which the href will be looked up.
///
/// The href for the specified cref.
///
public string GetHRef(string cref) {
if ((cref.Length < 2) || (cref[1] != ':')) {
return string.Empty;
}
// get the underlying type of the array
if (cref.EndsWith("[]")){
cref=cref.Replace("[]","");
}
// check if the ref is for a system namespaced element or not
if (cref.Length < 9 || (!cref.Substring(2).StartsWith(SystemPrefix) && !cref.Substring(2).StartsWith(MicrosoftWin32Prefix))) {
// not a system one.
// will hold the filename to link to
string fileName = null;
switch (cref.Substring(0, 2)) {
case "T:":
fileName = GetFileNameForType(cref, true);
break;
case "M:":
fileName = GetFileNameForFunction(cref, true);
break;
}
if (fileName == null) {
return string.Empty;
} else {
if (cref.Substring(2).StartsWith("NAnt.") && !cref.Substring(2).StartsWith("NAnt.Contrib")) {
return Config.NAntBaseUri + fileName;
} else {
return "../" + fileName;
}
}
} else {
// a system cref
switch (cref.Substring(0, 2)) {
case "N:": // Namespace
return SdkDocBaseUrl + cref.Substring(2).Replace(".", "") + SdkDocExt;
case "T:": // Type: class, interface, struct, enum, delegate
return SdkDocBaseUrl + cref.Substring(2).Replace(".", "") + "ClassTopic" + SdkDocExt;
case "F:": // Field
// do not generate href for fields, as the .NET SDK does
// not have separate pages for enum fields, and we have no
// way of knowing whether it's a reference to an enum field
// or class field.
return string.Empty;
case "P:": // Property
case "M:": // Method
case "E:": // Event
return this.GetFilenameForSystemMember(cref);
default:
return string.Empty;
}
}
}
///
/// Returns the name for a given cref.
///
/// The cref for which the name will be looked up.
///
/// The name for the specified cref.
///
public string GetName(string cref) {
if (cref.Length < 2) {
return cref;
}
if (cref[1] == ':') {
if (cref.Length < 9 || (!cref.Substring(2).StartsWith(SystemPrefix) && !cref.Substring(2).StartsWith(MicrosoftWin32Prefix))) {
//what name should be found?
string name = _elementNames[cref];
if (name != null) {
return name;
}
}
int index;
if ((index = cref.IndexOf(".#c")) >= 0) {
cref = cref.Substring(2, index - 2);
} else if ((index = cref.IndexOf("(")) >= 0) {
cref = cref.Substring(2, index - 2);
} else {
cref = cref.Substring(2);
}
}
return cref.Substring(cref.LastIndexOf(".") + 1);
}
///
/// Returns the NAnt task name for a given cref.
///
/// The cref for the task name will be looked up.
///
/// The NAnt task name for the specified cref.
///
public string GetTaskName(string cref) {
return GetTaskNameForType(GetTypeNodeByID(cref));
}
///
/// Returns the NAnt element name for a given cref.
///
/// The cref for the element name will be looked up.
///
/// The NAnt element name for the specified cref.
///
public string GetElementName(string cref) {
return GetElementNameForType(GetTypeNodeByID(cref));
}
public XmlNode GetTypeNodeByID(string cref) {
if (cref[1] == ':' && !cref.StartsWith("T:")) {
return null;
}
if (!cref.StartsWith("T:")) {
cref = "T:" + cref;
}
XmlNode typeNode = Document.SelectSingleNode("//class[@id='" + cref + "']");
if (typeNode == null) {
typeNode = Document.SelectSingleNode("//enumeration[@id='" + cref + "']");
}
return typeNode;
}
public XmlNode GetMethodNodeByID(string cref) {
if (cref[1] == ':' && !cref.StartsWith("M:")) {
return null;
}
if (!cref.StartsWith("M:")) {
cref = "M:" + cref;
}
return Document.SelectSingleNode("//method[@id='" + cref + "']");
}
///
/// Determines the of the given type node.
///
/// The type node for which to determine the .
///
/// The of the given type node.
///
public ElementDocType GetElementDocType(XmlNode typeNode) {
if (typeNode == null) {
return ElementDocType.None;
}
// check if type is an enum
if (typeNode.LocalName == "enumeration") {
return ElementDocType.Enum;
}
// check if type is a task
if (GetTaskNameForType(typeNode) != null) {
return ElementDocType.Task;
}
// check if type is a datatype
if (typeNode.SelectSingleNode("descendant::base[@id='T:" + typeof(DataTypeBase).FullName + "']") != null) {
if (typeNode.SelectSingleNode("attribute[@name='" + typeof(ElementNameAttribute).FullName + "']") != null) {
return ElementDocType.DataTypeElement;
} else {
return ElementDocType.Element;
}
}
// check if type is a filter
if (typeNode.SelectSingleNode("descendant::base[@id='T:" + typeof(Filter).FullName + "']") != null) {
if (typeNode.SelectSingleNode("attribute[@name='" + typeof(ElementNameAttribute).FullName + "']") != null) {
return ElementDocType.Filter;
} else {
return ElementDocType.Element;
}
}
// check if type is an element
if (typeNode.SelectSingleNode("descendant::base[@id='T:" + typeof(Element).FullName + "']") != null) {
return ElementDocType.Element;
}
// check if type is a functionset
if (typeNode.SelectSingleNode("attribute[@name='" + typeof(FunctionSetAttribute).FullName + "']/property[@name='Prefix']/@value") != null) {
return ElementDocType.FunctionSet;
}
return ElementDocType.None;
}
///
/// Determines the of the type to which
/// the given cref points.
///
/// The cref for which to determine the .
///
/// The of the type to which the given
/// cref points.
///
public ElementDocType GetElementDocTypeByID(string cref) {
return GetElementDocType(GetTypeNodeByID(cref));
}
///
/// Determines whether the given cref points to a datatype.
///
/// The cref to check.
///
/// if the given cref points to a datatype;
/// otherwise, .
///
public bool IsDataType(string cref) {
return GetElementDocTypeByID(cref) == ElementDocType.DataTypeElement;
}
///
/// Determines whether the given cref points to an element.
///
/// The cref to check.
///
/// if the given cref points to an element;
/// otherwise, .
///
///
/// When the cref points to a or
/// this method returns .
///
public bool IsElement(string cref) {
return GetElementDocTypeByID(cref) == ElementDocType.Element;
}
///
/// Determines whether the given cref points to a datatype.
///
/// The cref to check.
///
/// if the given cref points to a datatype;
/// otherwise, .
///
public bool IsFilter(string cref) {
return GetElementDocTypeByID(cref) == ElementDocType.Filter;
}
///
/// Determines whether the given cref points to a task.
///
/// The cref to check.
///
/// if the given cref points to a task;
/// otherwise, .
///
public bool IsTask(string cref) {
return GetElementDocTypeByID(cref) == ElementDocType.Task;
}
///
/// Determines whether the given cref points to a functionset.
///
/// The cref to check.
///
/// if the given cref points to a functionset;
/// otherwise, .
///
public bool IsFunctionSet(string cref) {
return GetElementDocTypeByID(cref) == ElementDocType.FunctionSet;
}
///
/// Encodes a URL string using for reliable
/// HTTP transmission from the Web server to a client.
///
/// The text to encode.
///
/// The encoded string.
///
public string UrlEncode(string value) {
return HttpUtility.UrlEncode(value, Encoding.UTF8);
}
#endregion Public Instance Methods
#region Internal Instance Methods
///
/// Gets the BuildElementAttribute name for the "class/property" XmlNode
///
/// The XmlNode to look for a name.
/// The BuildElementAttrbute.Name if the attribute exists for the node.
internal string GetElementNameForProperty(XmlNode propertyNode) {
// check whether property is a task attribute
XmlAttribute taskAttributeNode = propertyNode.SelectSingleNode("attribute[@name='" + typeof(TaskAttributeAttribute).FullName + "']/property[@name='Name']/@value") as XmlAttribute;
if (taskAttributeNode != null) {
return taskAttributeNode.Value;
}
// check whether property is a element array
XmlAttribute elementArrayNode = propertyNode.SelectSingleNode("attribute[@name='" + typeof(BuildElementArrayAttribute).FullName + "']/property[@name='Name']/@value") as XmlAttribute;
if (elementArrayNode != null) {
return elementArrayNode.Value;
}
// check whether property is a element collection
XmlAttribute elementCollectionNode = propertyNode.SelectSingleNode("attribute[@name='" + typeof(BuildElementCollectionAttribute).FullName + "']/property[@name='Name']/@value") as XmlAttribute;
if (elementCollectionNode != null) {
return elementCollectionNode.Value;
}
// check whether property is an xml element
XmlAttribute buildElementNode = propertyNode.SelectSingleNode("attribute[@name='" + typeof(BuildElementAttribute).FullName + "']/property[@name='Name']/@value") as XmlAttribute;
if (buildElementNode != null) {
return buildElementNode.Value;
}
// check whether property is a Framework configurable attribute
XmlAttribute frameworkConfigAttributeNode = propertyNode.SelectSingleNode("attribute[@name='" + typeof(FrameworkConfigurableAttribute).FullName + "']/property[@name='Name']/@value") as XmlAttribute;
if (frameworkConfigAttributeNode != null) {
return frameworkConfigAttributeNode.Value;
}
return null;
}
///
/// Returns the filename to use for the given function XmlElement
///
/// The "method" element to find the filename for.
/// Specified whether to URLencode the filename.
internal string GetFileNameForFunction(XmlNode functionNode, bool urlEncode) {
StringBuilder sb = new StringBuilder();
XmlNode n = functionNode.SelectSingleNode("../attribute[@name='NAnt.Core.Attributes.FunctionSetAttribute']/property[@name='Prefix']/@value");
if (n != null && n.InnerText != "") {
sb.Append(n.InnerText);
sb.Append('.');
}
n = functionNode.SelectSingleNode("attribute[@name='NAnt.Core.Attributes.FunctionAttribute']/property[@name='Name']/@value");
if (n != null && n.InnerText != "") {
sb.Append(n.InnerText);
} else {
sb.Append(functionNode.Attributes["name"].Value);
}
sb.Append('(');
XmlNodeList parameters = functionNode.SelectNodes("parameter");
for (int i = 0; i < parameters.Count; i++) {
if (i > 0)
sb.Append(',');
XmlElement param = (XmlElement) parameters[i];
sb.Append(param.GetAttribute("type"));
}
sb.Append(')');
string file = sb.ToString ();
return string.Concat("functions/", (urlEncode ? UrlEncode (file) : file), ".html");
}
///
/// Returns the filename to use for the given class XmlNode
///
/// The "Class" element to find the filename for.
///
/// The relative path and filename where this type is stored in the
/// documentation.
///
///
/// For a type that is neither a task, enum, global type, filter or
/// functionset, the returned filename will point to the SDK docs for
/// that type.
///
internal string GetFileNameForType(XmlNode typeNode, bool urlEncode) {
if (typeNode == null) {
return null;
}
string partialURL = null;
// if type is task use name set using TaskNameAttribute
string taskName = GetTaskNameForType(typeNode);
if (taskName != null) {
return "tasks/" + (urlEncode ? UrlEncode(taskName) : taskName) + ".html";
}
// check if type is an enum
if (typeNode.LocalName == "enumeration") {
string enumFile = typeNode.Attributes["id"].Value.Substring(2);
return "enums/" + (urlEncode ? UrlEncode(enumFile) : enumFile) + ".html";
}
// check if type derives from NAnt.Core.DataTypeBase
if (typeNode.SelectSingleNode("descendant::base[@id='T:" + typeof(DataTypeBase).FullName + "']") != null) {
// make sure the type has a ElementName assigned to it
XmlAttribute elementNameAttribute = typeNode.SelectSingleNode("attribute[@name='" + typeof(ElementNameAttribute).FullName + "']/property[@name='Name']/@value") as XmlAttribute;
if (elementNameAttribute != null) {
string dtFile = elementNameAttribute.Value;
return "types/" + (urlEncode ? UrlEncode(dtFile) : dtFile) + ".html";
}
}
// check if type derives from NAnt.Core.Filters.Filter
if (typeNode.SelectSingleNode("descendant::base[@id='T:" + typeof(Filter).FullName + "']") != null) {
// make sure the type has a ElementName assigned to it
XmlAttribute elementNameAttribute = typeNode.SelectSingleNode("attribute[@name='" + typeof(ElementNameAttribute).FullName + "']/property[@name='Name']/@value") as XmlAttribute;
if (elementNameAttribute != null) {
string filterFile = elementNameAttribute.Value;
return "filters/" + (urlEncode ? UrlEncode(filterFile) : filterFile) + ".html";
}
}
// check if type is a functionset
partialURL = GetHRefForFunctionSet(typeNode);
if (partialURL != null) {
return partialURL;
}
// check if type derives from NAnt.Core.Element
if (typeNode.SelectSingleNode("descendant::base[@id='T:" + typeof(Element).FullName + "']") != null) {
string elementFile = typeNode.Attributes["id"].Value.Substring(2);
return "elements/" + (urlEncode ? UrlEncode(elementFile) : elementFile) + ".html";
}
string sdkFile = typeNode.Attributes["id"].Value.Substring(2);
return "../sdk/" + (urlEncode ? UrlEncode(sdkFile) : sdkFile) + ".html";
}
#endregion Internal Instance Methods
#region Private Instance Methods
private string GetElementNameForType(XmlNode typeNode) {
if (typeNode == null) {
return string.Empty;
}
// if type is task use name set using TaskNameAttribute
string taskName = GetTaskNameForType(typeNode);
if (taskName != null) {
return "<" + taskName + ">";
}
// make sure the type has a ElementNameAttribute assigned to it
XmlAttribute elementNameAttribute = typeNode.SelectSingleNode("attribute[@name='" + typeof(ElementNameAttribute).FullName + "']/property[@name='Name']/@value") as XmlAttribute;
if (elementNameAttribute != null) {
// check if we're dealing with a data type
if (typeNode.SelectSingleNode("descendant::base[@id='T:" + typeof(DataTypeBase).FullName + "']")!= null) {
return "<" + elementNameAttribute.Value + ">";
}
// check if we're dealing with a filter
if (typeNode.SelectSingleNode("descendant::base[@id='T:" + typeof(Filter).FullName + "']")!= null) {
return "<" + elementNameAttribute.Value + ">";
}
}
// if we're dealing with a FunctionSet, use category as name instead
// of prefix
XmlAttribute categoryNameAttribute = typeNode.SelectSingleNode("attribute[@name='" + typeof(FunctionSetAttribute).FullName + "']/property[@name='Category']/@value") as XmlAttribute;
if (categoryNameAttribute != null) {
return categoryNameAttribute.Value;
}
return null;
}
private string GetFileNameForFunction(string type, bool urlEncode) {
XmlNode functionNode = GetMethodNodeByID(type);
if (functionNode != null) {
return GetFileNameForFunction(functionNode, true);
}
return null;
}
private string GetFileNameForType(string type, bool urlEncode) {
return GetFileNameForType(GetTypeNodeByID(type), urlEncode);
}
private string GetFilenameForSystemMember(string cref) {
string crefName;
int index;
if ((index = cref.IndexOf(".#c")) >= 0) {
crefName = cref.Substring(2, index - 2) + ".ctor";
} else if ((index = cref.IndexOf("(")) >= 0) {
crefName = cref.Substring(2, index - 2);
} else {
crefName = cref.Substring(2);
}
index = crefName.LastIndexOf(".");
string crefType = crefName.Substring(0, index);
string crefMember = crefName.Substring(index + 1);
return SdkDocBaseUrl + crefType.Replace(".", "") + "Class" + crefMember + "Topic" + SdkDocExt;
}
///
/// Gets the TaskNameAttrbute name for the "class" XmlNode
///
/// The XmlNode to look for a name.
/// The if the attribute exists for the node.
///
/// The class is also checked to make sure it is derived from
///
private string GetTaskNameForType(XmlNode typeNode) {
if (typeNode == null) {
return null;
}
// make sure the type actually derives from NAnt.Core.Task
if (typeNode.SelectSingleNode("descendant::base[@id='T:" + typeof(Task).FullName + "']") != null) {
// make sure the type has a TaskNameAttribute assigned to it
XmlAttribute taskNameAttribute = typeNode.SelectSingleNode("attribute[@name='" + typeof(TaskNameAttribute).FullName + "']/property[@name='Name']/@value") as XmlAttribute;
if (taskNameAttribute != null) {
return taskNameAttribute.Value;
}
}
return null;
}
///
/// Gets the function name for methods that represent a NAtn function.
///
/// The XmlNode to look for a name.
///
/// The function name if represent a
/// NAnt function.
///
private string GetElementNameForMethod(XmlNode methodNode) {
XmlNode functionNameAttribute = methodNode.SelectSingleNode("attribute[@name='" + typeof(FunctionAttribute).FullName + "']/property[@name='Name']/@value");
if (functionNameAttribute == null) {
return methodNode.Attributes["name"].Value;
}
XmlNode prefixAttribute = methodNode.SelectSingleNode("../attribute[@name='" + typeof(FunctionSetAttribute).FullName + "']/property[@name='Prefix']/@value");
if (prefixAttribute == null) {
return methodNode.Attributes["name"].Value;
}
return prefixAttribute.InnerText + "::" + functionNameAttribute.InnerText + "()";
}
///
/// Returns a partial URL to link to the functionset in the function index.
///
/// The "Class" element to find the filename for.
private string GetHRefForFunctionSet(XmlNode functionNode) {
XmlAttribute categoryValueAttribute = functionNode.SelectSingleNode("attribute[@name='NAnt.Core.Attributes.FunctionSetAttribute']/property[@name='Category']/@value") as XmlAttribute;
if (categoryValueAttribute != null && categoryValueAttribute.Value != "") {
return "functions/index.html#" + UrlEncode(categoryValueAttribute.Value);
}
return null;
}
#endregion Private Instance Methods
#region Internal Static Methods
internal static NAntXsltUtilities CreateInstance(XmlDocument doc, NAntDocumenterConfig config){
// just in case... but we should never see this happen.
lock (Instances) {
foreach (NAntXsltUtilities util in Instances) {
if (util.Document == doc && util.Config.SdkDocVersion.Equals(config.SdkDocVersion) && util.Config.SdkLinksOnWeb == config.SdkLinksOnWeb) {
return util;
}
}
NAntXsltUtilities inst = new NAntXsltUtilities(doc, config);
Instances.Add(inst);
return inst;
}
}
#endregion Internal Static Methods
}
}
nant-0.92-rc1/src/NDoc.Documenter.NAnt/Resources/ 0000755 0001750 0001750 00000000000 11757310030 021345 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NDoc.Documenter.NAnt/Resources/filter-index.xslt 0000644 0001750 0001750 00000013460 11757302275 024673 0 ustar jtaylor jtaylor
Filter Reference
The function will fail in any of the following circumstances:
nant-0.92-rc1/src/NDoc.Documenter.NAnt/Resources/tags.xslt 0000644 0001750 0001750 00000037010 11757302275 023234 0 ustar jtaylor jtaylor
A normal paragraph. This ends up being a p tag.
(Did we really need the extra three letters?)
Use the lang attribute to indicate that the text of the
paragraph is only appropriate for a specific language.
[]
Multiple lines of code.
Use the lang attribute to indicate that the code
sample is only appropriate for a specific language.
nant-0.92-rc1/src/NDoc.Documenter.NAnt/NDoc.Documenter.NAnt.build 0000644 0001750 0001750 00000003363 11757302275 024223 0 ustar jtaylor jtaylor
nant-0.92-rc1/src/NDoc.Documenter.NAnt/NDoc.Documenter.NAnt.csproj 0000644 0001750 0001750 00000011260 11757302275 024417 0 ustar jtaylor jtaylor
DebugAnyCPU2.0{841FAEBA-4527-410A-B765-E2EDA47ABDCE}NDoc.Documenter.NAntNDoc.Documenter.NAntLibraryOnSuccessfulBuildfalse8.0.50727v2.02.0publish\trueDiskfalseForeground7Daysfalsefalsetrue01.0.0.%2afalsefalsetruetruefullfalse4..\..\build\Debug\AllRules.rulesetTRACE;DEBUG..\..\build\Debug\NDoc.Documenter.NAnt.xmltruepdbonlytrue..\..\build\Release\4AllRules.rulesetTRACE..\..\build\Release\NDoc.Documenter.NAnt.xml..\..\lib\common\neutral\NDoc.Core.dll
CommonAssemblyInfo.cs
False.NET Framework 3.5 SP1 Client ProfilefalseFalse.NET Framework 3.5 SP1trueFalseWindows Installer 3.1true{8F5F8375-4097-4952-B860-784EB9961ABE}NAnt.Core nant-0.92-rc1/src/NAnt.VSNet/ 0000755 0001750 0001750 00000000000 11757310030 015443 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.VSNet/VcProject.cs 0000644 0001750 0001750 00000253456 11757302274 017723 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Dmitry Jemerov
// Scott Ford (sford@RJKTECH.com)
// Gert Driesen (drieseng@users.sourceforge.net)
// Hani Atassi (haniatassi@users.sourceforge.net)
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Text;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.VisualCpp.Tasks;
using NAnt.VisualCpp.Types;
using NAnt.VSNet.Tasks;
using NAnt.VSNet.Types;
namespace NAnt.VSNet {
///
/// Visual C++ project.
///
public class VcProject: ProjectBase {
#region Public Instance Constructors
public VcProject(SolutionBase solution, string projectPath, XmlElement xmlDefinition,
SolutionTask solutionTask,
TempFileCollection tfc,
GacCache gacCache,
ReferencesResolver refResolver,
DirectoryInfo outputDir)
: base(xmlDefinition, solutionTask, tfc, gacCache, refResolver, outputDir) {
if (projectPath == null) {
throw new ArgumentNullException("projectPath");
}
_references = new ArrayList();
_clArgMap = VcArgumentMap.CreateCLArgumentMap();
_linkerArgMap = VcArgumentMap.CreateLinkerArgumentMap();
_midlArgMap = VcArgumentMap.CreateMidlArgumentMap();
_projectPath = FileUtils.GetFullPath(projectPath);
_name = xmlDefinition.GetAttribute("Name");
_guid = xmlDefinition.GetAttribute("ProjectGUID");
XmlNodeList configurationNodes = xmlDefinition.SelectNodes("//Configurations/Configuration");
foreach (XmlElement configElem in configurationNodes) {
VcProjectConfiguration config = new VcProjectConfiguration(configElem, this, OutputDir);
ProjectConfigurations[new Configuration (config.Name, config.PlatformName)] = config;
}
XmlNodeList references = xmlDefinition.SelectNodes("//References/child::*");
foreach (XmlElement referenceElem in references) {
ReferenceBase reference = CreateReference(solution, referenceElem);
_references.Add(reference);
}
XmlNodeList fileNodes = xmlDefinition.SelectNodes("//File");
_projectFiles = new ArrayList(fileNodes.Count);
foreach (XmlElement fileElem in fileNodes) {
string parentName = Name;
// determine name of parent
if (fileElem.ParentNode != null && fileElem.ParentNode.Name == "Filter") {
XmlNode filterName = fileElem.ParentNode.Attributes.GetNamedItem("Name");
if (filterName != null) {
parentName = filterName.Value;
}
}
string relPath = fileElem.GetAttribute("RelativePath");
Hashtable htFileConfigurations = null;
XmlNodeList fileConfigList = fileElem.GetElementsByTagName("FileConfiguration");
if (fileConfigList.Count > 0) {
htFileConfigurations = CollectionsUtil.CreateCaseInsensitiveHashtable(fileConfigList.Count);
foreach (XmlElement fileConfigElem in fileConfigList) {
Configuration fileConfig = Configuration.Parse (
fileConfigElem.GetAttribute("Name"));
VcProjectConfiguration projectConfig = (VcProjectConfiguration) ProjectConfigurations[fileConfig];
htFileConfigurations[projectConfig.Name] = new VcFileConfiguration(
relPath, parentName, fileConfigElem, projectConfig, outputDir);
}
}
// TODO: refactor this together with the Build methods
// we'll always create a file configuration for IDL and res
// files as macro's in the configuration properties for these
// files will always need to be expanded on the file level
string ext = Path.GetExtension(relPath).ToLower(CultureInfo.InvariantCulture);
switch (ext) {
case ".idl":
case ".odl":
case ".rc":
// ensure there's a file configuration for each project
// configuration
foreach (VcProjectConfiguration projectConfig in ProjectConfigurations.Values) {
// if file configuration for project config existed
// in project file, then skip this project config
if (htFileConfigurations != null && htFileConfigurations.ContainsKey(projectConfig.Name)) {
continue;
}
// lazy initialize hashtable
if (htFileConfigurations == null) {
htFileConfigurations = CollectionsUtil.CreateCaseInsensitiveHashtable();
}
// create the file configuration
htFileConfigurations[projectConfig.Name] = new
VcFileConfiguration(relPath, parentName, projectConfig, outputDir);
}
break;
}
if (htFileConfigurations != null) {
_projectFiles.Add(htFileConfigurations);
} else {
_projectFiles.Add(relPath);
}
}
}
#endregion Public Instance Constructors
#region Override implementation of ProjectBase
///
/// Gets the name of the Visual C++ project.
///
public override string Name {
get { return _name; }
}
///
/// Gets the type of the project.
///
///
/// The type of the project.
///
public override ProjectType Type {
get { return ProjectType.VisualC; }
}
///
/// Gets the path of the Visual C++ project.
///
public override string ProjectPath {
get { return _projectPath; }
}
///
/// Gets the directory containing the VS.NET project.
///
public override DirectoryInfo ProjectDirectory {
get { return new DirectoryInfo(Path.GetDirectoryName(_projectPath)); }
}
///
/// Get the location of the project.
///
///
/// .
///
///
/// For now, we only support local Visual C++ projects.
///
public override ProjectLocation ProjectLocation {
get { return ProjectLocation.Local; }
}
///
/// Get the directory in which intermediate build output that is not
/// specific to the build configuration will be stored.
///
///
/// This is a directory relative to the project directory,
/// named temp\.
///
public override DirectoryInfo ObjectDir {
get {
return new DirectoryInfo(
FileUtils.CombinePaths(ProjectDirectory.FullName, "temp"));
}
}
///
/// Gets or sets the unique identifier of the Visual C++ project.
///
public override string Guid {
get { return _guid; }
set { _guid = value; }
}
public override ArrayList References {
get { return _references; }
}
public override ProjectReferenceBase CreateProjectReference(ProjectBase project, bool isPrivateSpecified, bool isPrivate) {
return new VcProjectReference(project, this, isPrivateSpecified,
isPrivate);
}
///
/// Gets a value indicating whether building the project for the specified
/// build configuration results in managed output.
///
/// The solution configuration that is built.
///
/// if the project output for the specified build
/// configuration is either a Dynamic Library (dll) or an Application
/// (exe), and Managed Extensions are enabled; otherwise,
/// .
///
public override bool IsManaged(Configuration solutionConfiguration) {
VcProjectConfiguration projectConfig = (VcProjectConfiguration)
BuildConfigurations[solutionConfiguration];
return (projectConfig.Type == VcProjectConfiguration.ConfigurationType.DynamicLibrary ||
projectConfig.Type == VcProjectConfiguration.ConfigurationType.Application) &&
projectConfig.ManagedExtensions;
}
///
/// Verifies whether the specified XML fragment represents a valid project
/// that is supported by this .
///
/// XML fragment representing the project file.
///
/// The XML fragment is not supported by this .
/// -or-
/// The XML fragment does not represent a valid project (for this ).
///
protected override void VerifyProjectXml(XmlElement docElement) {
if (!IsSupported(docElement)) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Project '{0}' is not a valid Visual C++ project.",
ProjectPath), Location.UnknownLocation);
}
}
///
/// Returns the Visual Studio product version of the specified project
/// XML fragment.
///
/// The document element of the project.
///
/// The Visual Studio product version of the specified project XML
/// fragment.
///
///
/// The product version could not be determined.
/// -or-
/// The product version is not supported.
///
protected override ProductVersion DetermineProductVersion(XmlElement docElement) {
return GetProductVersion(docElement);
}
protected override BuildResult Build(Configuration solutionConfiguration) {
// prepare the project for build
Prepare(solutionConfiguration);
// obtain project configuration (corresponding with solution configuration)
VcProjectConfiguration projectConfig = (VcProjectConfiguration) BuildConfigurations[solutionConfiguration];
// perform pre-build actions
if (!PreBuild(projectConfig)) {
return BuildResult.Failed;
}
string nmakeCommand = projectConfig.GetToolSetting(VcConfigurationBase.NMakeTool, "BuildCommandLine");
if (!String.IsNullOrEmpty(nmakeCommand)) {
RunNMake(nmakeCommand);
return BuildResult.Success;
}
VcConfigurationBase stdafxConfig = null;
// build idl files before everything else
foreach (VcConfigurationBase idlConfig in projectConfig.IdlConfigs.Keys) {
BuildIDLFiles((ArrayList) projectConfig.IdlConfigs[idlConfig],
projectConfig, idlConfig);
}
// If VC project uses precompiled headers then the precompiled header
// output (.pch file) must be generated before compiling any other
// source files.
foreach (VcConfigurationBase vcConfig in projectConfig.SourceConfigs.Keys) {
if (vcConfig.UsePrecompiledHeader == UsePrecompiledHeader.Create) {
BuildCPPFiles((ArrayList) projectConfig.SourceConfigs[vcConfig],
solutionConfiguration, vcConfig);
stdafxConfig = vcConfig;
}
}
foreach (VcConfigurationBase vcConfig in projectConfig.SourceConfigs.Keys) {
if (vcConfig != stdafxConfig) {
BuildCPPFiles((ArrayList) projectConfig.SourceConfigs[vcConfig],
solutionConfiguration, vcConfig);
}
}
// build resource files
foreach (VcConfigurationBase rcConfig in projectConfig.RcConfigs.Keys) {
BuildResourceFiles((ArrayList) projectConfig.RcConfigs[rcConfig],
projectConfig, rcConfig);
}
switch (projectConfig.Type) {
case VcProjectConfiguration.ConfigurationType.StaticLibrary:
RunLibrarian(projectConfig);
break;
case VcProjectConfiguration.ConfigurationType.Application:
case VcProjectConfiguration.ConfigurationType.DynamicLibrary:
// perform pre-link actions
if (!PreLink(projectConfig)) {
return BuildResult.Failed;
}
RunLinker(solutionConfiguration);
break;
}
Log(Level.Verbose, "Copying references:");
foreach (ReferenceBase reference in _references) {
if (reference.CopyLocal) {
Log(Level.Verbose, " - " + reference.Name);
Hashtable outputFiles = CollectionsUtil.CreateCaseInsensitiveHashtable();
reference.GetOutputFiles(solutionConfiguration, outputFiles);
foreach (DictionaryEntry de in outputFiles) {
// determine file to copy
FileInfo srcFile = new FileInfo((string) de.Key);
// determine destination file
FileInfo destFile = new FileInfo(FileUtils.CombinePaths(
projectConfig.OutputDir.FullName, (string) de.Value));
// perform actual copy
CopyFile(srcFile, destFile, SolutionTask);
}
}
}
// run custom build steps
if (!RunCustomBuildStep(solutionConfiguration, projectConfig)) {
return BuildResult.Failed;
}
// perform post-build actions
if (!PostBuild(projectConfig)) {
return BuildResult.Failed;
}
return BuildResult.Success;
}
#endregion Override implementation of ProjectBase
#region Internal Instance Properties
internal ArrayList ProjectFiles {
get { return _projectFiles; }
}
#endregion Internal Instance Properties
#region Protected Internal Instance Methods
///
/// Expands the given macro.
///
/// The macro to expand.
///
/// The expanded macro or if the macro is not
/// supported.
///
protected internal override string ExpandMacro(string macro) {
// perform case-insensitive expansion of macros
switch (macro.ToLower(CultureInfo.InvariantCulture)) {
case "inputdir":
return Path.GetDirectoryName(ProjectPath)
+ Path.DirectorySeparatorChar;
case "inputname":
return Path.GetFileNameWithoutExtension(ProjectPath);
case "inputpath":
return ProjectPath;
case "inputfilename": // E.g. Inc.vcproj
return Path.GetFileName(ProjectPath);
case "inputext": // E.g. .vcproj
return Path.GetExtension(ProjectPath);
case "safeparentname":
return Name;
case "safeinputname":
return Path.GetFileNameWithoutExtension(ProjectPath);
default:
return base.ExpandMacro(macro);
}
}
#endregion Protected Internal Instance Methods
#region Internal Instance Methods
internal string GetObjOutputFile(string fileName, VcConfigurationBase fileConfig, string intermediateDir) {
string objectFile = GetObjectFile(fileConfig);
if (objectFile == null) {
objectFile = intermediateDir;
}
return ClTask.GetObjOutputFile(fileName, objectFile);
}
internal string GetResourceOutputFile(string fileName, VcConfigurationBase fileConfig) {
return FileUtils.CombinePaths(ProjectDirectory.FullName,
fileConfig.GetToolSetting(VcConfigurationBase.ResourceCompilerTool,
"ResourceOutputFileName", "$(IntDir)/$(InputName).res"));
}
#endregion Internal Instance Methods
#region Protected Instance Methods
protected virtual ReferenceBase CreateReference(SolutionBase solution, XmlElement xmlDefinition) {
if (solution == null) {
throw new ArgumentNullException("solution");
}
if (xmlDefinition == null) {
throw new ArgumentNullException("xmlDefinition");
}
switch (xmlDefinition.Name) {
case "ProjectReference":
// project reference
return new VcProjectReference(xmlDefinition, ReferencesResolver,
this, solution, solution.TemporaryFiles, GacCache,
OutputDir);
case "AssemblyReference":
// assembly reference
return new VcAssemblyReference(xmlDefinition, ReferencesResolver,
this, GacCache);
case "ActiveXReference":
// ActiveX reference
return new VcWrapperReference(xmlDefinition, ReferencesResolver,
this, GacCache);
default:
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"\"{0}\" reference not supported.", xmlDefinition.Name),
Location.UnknownLocation);
}
}
#endregion Protected Instance Methods
#region Private Instance Methods
private void RunNMake(string nmakeCommand) {
// store current directory
string originalCurrentDirectory = Directory.GetCurrentDirectory();
try {
// change current directory to directory containing
// project file
Directory.SetCurrentDirectory(ProjectDirectory.FullName);
// execute command
ExecTask nmakeTask = new ExecTask();
nmakeTask.Project = SolutionTask.Project;
nmakeTask.Parent = SolutionTask;
nmakeTask.Verbose = SolutionTask.Verbose;
nmakeTask.CommandLineArguments =
"/c \"" + nmakeCommand + "\"";
nmakeTask.FileName = "cmd.exe";
ExecuteInProjectDirectory(nmakeTask);
} finally {
// restore original current directory
Directory.SetCurrentDirectory(originalCurrentDirectory);
}
}
private void BuildCPPFiles(ArrayList fileNames, Configuration solutionConfiguration, VcConfigurationBase fileConfig) {
// obtain project configuration (corresponding with solution configuration)
VcProjectConfiguration projectConfig = (VcProjectConfiguration) BuildConfigurations[solutionConfiguration];
string intermediateDir = FileUtils.CombinePaths(ProjectDirectory.FullName,
projectConfig.IntermediateDir);
// create instance of Cl task
ClTask clTask = new ClTask();
// inherit project from solution task
clTask.Project = SolutionTask.Project;
// inherit namespace manager from solution task
clTask.NamespaceManager = SolutionTask.NamespaceManager;
// parent is solution task
clTask.Parent = SolutionTask;
// inherit verbose setting from solution task
clTask.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
clTask.InitializeTaskConfiguration();
// set parent of child elements
clTask.IncludeDirs.Parent = clTask;
clTask.Sources.Parent = clTask;
clTask.MetaDataIncludeDirs.Parent = clTask;
clTask.ForcedUsingFiles.Parent = clTask;
// inherit project from solution task for child elements
clTask.IncludeDirs.Project = clTask.Project;
clTask.Sources.Project = clTask.Project;
clTask.MetaDataIncludeDirs.Project = clTask.Project;
clTask.ForcedUsingFiles.Project = clTask.Project;
// set namespace manager of child elements
clTask.IncludeDirs.NamespaceManager = clTask.NamespaceManager;
clTask.Sources.NamespaceManager = clTask.NamespaceManager;
clTask.MetaDataIncludeDirs.NamespaceManager = clTask.NamespaceManager;
clTask.ForcedUsingFiles.NamespaceManager = clTask.NamespaceManager;
// set base directories
clTask.IncludeDirs.BaseDirectory = ProjectDirectory;
clTask.Sources.BaseDirectory = ProjectDirectory;
clTask.MetaDataIncludeDirs.BaseDirectory = ProjectDirectory;
clTask.ForcedUsingFiles.BaseDirectory = ProjectDirectory;
// set task properties
clTask.OutputDir = new DirectoryInfo(intermediateDir);
// TODO: add support for disabling specific warnings !!!
// check if precompiled headers are used
if (fileConfig.UsePrecompiledHeader != UsePrecompiledHeader.No && fileConfig.UsePrecompiledHeader != UsePrecompiledHeader.Unspecified) {
// get location of precompiled header file
string pchFile = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool,
"PrecompiledHeaderFile", "$(IntDir)/$(TargetName).pch");
// we must set an absolute path for the PCH location file,
// otherwise assumes a location relative to the output
// directory - not the project directory.
if (!String.IsNullOrEmpty(pchFile)) {
clTask.PchFile = FileUtils.CombinePaths(ProjectDirectory.FullName, pchFile);
}
// check if a header file is specified for the precompiled header
// file, use "StdAfx.h" as default value
string headerThrough = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool,
"PrecompiledHeaderThrough", "StdAfx.h");
if (!String.IsNullOrEmpty(headerThrough)) {
clTask.PchThroughFile = headerThrough;
}
switch (fileConfig.UsePrecompiledHeader) {
case UsePrecompiledHeader.Use:
clTask.PchMode = ClTask.PrecompiledHeaderMode.Use;
break;
case UsePrecompiledHeader.AutoCreate:
clTask.PchMode = ClTask.PrecompiledHeaderMode.AutoCreate;
break;
case UsePrecompiledHeader.Create:
clTask.PchMode = ClTask.PrecompiledHeaderMode.Create;
break;
}
}
clTask.CharacterSet = projectConfig.CharacterSet;
// ensure output directory exists
if (!clTask.OutputDir.Exists) {
clTask.OutputDir.Create();
clTask.OutputDir.Refresh();
}
string includeDirs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "AdditionalIncludeDirectories");
if (!String.IsNullOrEmpty(includeDirs)) {
foreach (string includeDir in includeDirs.Split(',', ';')) {
if (includeDir.Length == 0) {
continue;
}
clTask.IncludeDirs.DirectoryNames.Add(FileUtils.CombinePaths(
ProjectDirectory.FullName, CleanPath(includeDir)));
}
}
string metadataDirs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "AdditionalUsingDirectories");
if (!String.IsNullOrEmpty(metadataDirs)) {
foreach (string metadataDir in metadataDirs.Split(';')) {
if (metadataDir.Length == 0) {
continue;
}
clTask.MetaDataIncludeDirs.DirectoryNames.Add(
CleanPath(fileConfig.ExpandMacros(metadataDir)));
}
}
string forcedUsingFiles = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "ForcedUsingFiles");
if (!String.IsNullOrEmpty(forcedUsingFiles)) {
foreach (string forcedUsingFile in forcedUsingFiles.Split(';')) {
if (forcedUsingFile.Length == 0) {
continue;
}
clTask.ForcedUsingFiles.Includes.Add(
CleanPath(fileConfig.ExpandMacros(forcedUsingFile)));
}
}
// add project and assembly references
foreach (ReferenceBase reference in References) {
if (!reference.IsManaged(solutionConfiguration)) {
continue;
}
StringCollection assemblyReferences = reference.GetAssemblyReferences(
solutionConfiguration);
foreach (string assemblyFile in assemblyReferences) {
clTask.ForcedUsingFiles.Includes.Add(assemblyFile);
}
}
// Since the name of the pdb file is based on the VS version, we need to see
// which version we are targeting to make sure the right pdb file is used.
string pdbTargetFileName;
switch (ProductVersion) {
case ProductVersion.Rosario:
pdbTargetFileName = "$(IntDir)/vc100.pdb";
break;
case ProductVersion.Orcas:
pdbTargetFileName = "$(IntDir)/vc90.pdb";
break;
case ProductVersion.Whidbey:
pdbTargetFileName = "$(IntDir)/vc80.pdb";
break;
default:
pdbTargetFileName = "$(IntDir)/vc70.pdb";
break;
}
// set name of program database file
//
// we must set an absolute path for the program database file,
// otherwise assumes a location relative to the output
// directory - not the project directory.
string pdbFile = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool,
"ProgramDataBaseFileName", pdbTargetFileName);
if (!String.IsNullOrEmpty(pdbFile)) {
clTask.ProgramDatabaseFile = FileUtils.CombinePaths(ProjectDirectory.FullName,
pdbFile);
}
// set path of object file or directory (can be null)
clTask.ObjectFile = GetObjectFile(fileConfig);
string asmOutput = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "AssemblerOutput");
string asmListingLocation = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "AssemblerListingLocation");
if (!String.IsNullOrEmpty(asmOutput) && asmOutput != "0" && !String.IsNullOrEmpty(asmListingLocation)) {
// parameter for AssemblerOutput itself will be handled by the map
clTask.Arguments.Add(new Argument("/Fa\"" + asmListingLocation + "\""));
}
foreach (string fileName in fileNames) {
clTask.Sources.FileNames.Add(FileUtils.CombinePaths(
ProjectDirectory.FullName, fileName));
}
string preprocessorDefs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "PreprocessorDefinitions");
if (!String.IsNullOrEmpty(preprocessorDefs)) {
foreach (string def in preprocessorDefs.Split(';', ',')) {
if (def.Length != 0) {
Option op = new Option();
op.OptionName = def;
clTask.Defines.Add(op);
}
}
}
string undefinePreprocessorDefs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "UndefinePreprocessorDefinitions");
if (!String.IsNullOrEmpty(undefinePreprocessorDefs)) {
foreach (string def in undefinePreprocessorDefs.Split(';', ',')) {
Option op = new Option();
op.OptionName = def;
clTask.Undefines.Add(op);
}
}
string addOptions = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "AdditionalOptions");
if (!String.IsNullOrEmpty(addOptions)) {
using (StringReader reader = new StringReader(addOptions)) {
string addOptionsLine = reader.ReadLine();
while (addOptionsLine != null) {
foreach (string addOption in addOptionsLine.Split(' ')) {
clTask.Arguments.Add(new Argument(addOption));
}
addOptionsLine = reader.ReadLine();
}
}
}
//exception handling stuff
string exceptionHandling = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "ExceptionHandling");
if (exceptionHandling == null) {
if (ProductVersion >= ProductVersion.Whidbey) {
exceptionHandling = "2";
} else {
exceptionHandling = "false";
}
} else {
exceptionHandling = exceptionHandling.ToLower();
}
switch(exceptionHandling) {
case "0":
case "false":
break;
case "1":
case "true":
clTask.Arguments.Add(new Argument("/EHsc"));
break;
case "2":
clTask.Arguments.Add(new Argument("/EHa"));
break;
}
string browseInformation = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "BrowseInformation");
if (!String.IsNullOrEmpty(browseInformation) && browseInformation != "0") {
// determine file name of browse information file
string browseInformationFile = fileConfig.GetToolSetting(
VcConfigurationBase.CLCompilerTool, "BrowseInformationFile",
"$(IntDir)/");
if (!String.IsNullOrEmpty(browseInformationFile)) {
switch (browseInformation) {
case "1": // Include All Browse Information
clTask.Arguments.Add(new Argument("/FR\""
+ browseInformationFile + "\""));
break;
case "2": // No Local Symbols
clTask.Arguments.Add(new Argument("/Fr\""
+ browseInformationFile + "\""));
break;
}
} else {
switch (browseInformation) {
case "1": // Include All Browse Information
clTask.Arguments.Add(new Argument("/FR"));
break;
case "2": // No Local Symbols
clTask.Arguments.Add(new Argument("/Fr"));
break;
}
}
}
if (projectConfig.Type == VcProjectConfiguration.ConfigurationType.DynamicLibrary) {
clTask.Arguments.Add(new Argument("/D"));
clTask.Arguments.Add(new Argument("_WINDLL"));
}
if (projectConfig.WholeProgramOptimization) {
clTask.Arguments.Add(new Argument("/GL"));
}
// used to ignore some arguments
VcArgumentMap.ArgGroup vcArgIgnoreGroup = VcArgumentMap.ArgGroup.Unassigned;
// if optimzation level is Minimum Size (1) or Maximum size (2), we
// need to ignore all the arguments of the group "OptiIgnoreGroup"
string optimization = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "Optimization");
if (!String.IsNullOrEmpty(optimization)) {
int optimizationLevel = int.Parse(optimization);
if (optimizationLevel == 1 || optimizationLevel == 2) {
vcArgIgnoreGroup |= VcArgumentMap.ArgGroup.OptiIgnoreGroup;
}
}
Hashtable compilerArgs = fileConfig.GetToolArguments(VcConfigurationBase.CLCompilerTool,
_clArgMap, vcArgIgnoreGroup);
foreach (string arg in compilerArgs.Values) {
Argument compilerArg = new Argument();
compilerArg.Line = arg;
clTask.Arguments.Add(compilerArg);
}
// check for shared MFC
if (projectConfig.UseOfMFC == UseOfMFC.Shared) {
clTask.Arguments.Add(new Argument("/D"));
clTask.Arguments.Add(new Argument("_AFXDLL"));
}
// check for shared ATL
switch (projectConfig.UseOfATL) {
case UseOfATL.Shared:
clTask.Arguments.Add(new Argument("/D"));
clTask.Arguments.Add(new Argument("_ATL_DLL"));
break;
case UseOfATL.Static:
clTask.Arguments.Add(new Argument("/D"));
clTask.Arguments.Add(new Argument("_ATL_STATIC_REGISTRY"));
break;
}
// enable/disable Managed Extensions for C++
clTask.ManagedExtensions = projectConfig.ManagedExtensions;
// execute the task
ExecuteInProjectDirectory(clTask);
}
///
/// Build resource files for the given configuration.
///
/// The resource files to build.
/// The project configuration.
/// The build configuration.
///
/// TODO: refactor this as we should always get only one element in the
/// list. Each res file should be built
/// with its own file configuration.
///
private void BuildResourceFiles(ArrayList fileNames, VcProjectConfiguration projectConfig, VcConfigurationBase fileConfig) {
// create instance of RC task
RcTask rcTask = new RcTask();
// inherit project from solution task
rcTask.Project = SolutionTask.Project;
// Set the base directory
rcTask.BaseDirectory = ProjectDirectory;
// inherit namespace manager from solution task
rcTask.NamespaceManager = SolutionTask.NamespaceManager;
// parent is solution task
rcTask.Parent = SolutionTask;
// inherit verbose setting from solution task
rcTask.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
rcTask.InitializeTaskConfiguration();
// set parent of child elements
rcTask.IncludeDirs.Parent = rcTask;
// inherit project from solution task for child elements
rcTask.IncludeDirs.Project = rcTask.Project;
// set namespace manager of child elements
rcTask.IncludeDirs.NamespaceManager = rcTask.NamespaceManager;
// set base directories
rcTask.IncludeDirs.BaseDirectory = ProjectDirectory;
// Store the options to pass to the resource compiler in the options variable
StringBuilder options = new StringBuilder();
// Collect options
string ignoreStandardIncludePath = fileConfig.GetToolSetting(VcConfigurationBase.ResourceCompilerTool, "IgnoreStandardIncludePath");
if (ignoreStandardIncludePath != null && string.Compare(ignoreStandardIncludePath, "true", true, CultureInfo.InvariantCulture) == 0) {
options.Append("/X ");
}
string culture = fileConfig.GetToolSetting(VcConfigurationBase.ResourceCompilerTool, "Culture");
if (!String.IsNullOrEmpty(culture)) {
int cultureId = Convert.ToInt32(culture);
rcTask.LangId = cultureId;
}
string preprocessorDefs = fileConfig.GetToolSetting(VcConfigurationBase.ResourceCompilerTool, "PreprocessorDefinitions");
if (!String.IsNullOrEmpty(preprocessorDefs)) {
foreach (string preprocessorDef in preprocessorDefs.Split(';')) {
if (preprocessorDef.Length == 0) {
continue;
}
Option op = new Option();
op.OptionName = preprocessorDef;
rcTask.Defines.Add(op);
}
}
string showProgress = fileConfig.GetToolSetting(VcConfigurationBase.ResourceCompilerTool, "ShowProgress");
if (showProgress != null && string.Compare(showProgress, "true", true, CultureInfo.InvariantCulture) == 0) {
rcTask.Verbose = true;
}
string addIncludeDirs = MergeToolSetting(projectConfig, fileConfig, VcConfigurationBase.ResourceCompilerTool, "AdditionalIncludeDirectories");
if (!String.IsNullOrEmpty(addIncludeDirs)) {
foreach (string includeDir in addIncludeDirs.Split(';')) {
if (includeDir.Length == 0) {
continue;
}
rcTask.IncludeDirs.DirectoryNames.Add(FileUtils.CombinePaths(
ProjectDirectory.FullName, CleanPath(includeDir)));
}
}
// check for shared MFC
if (projectConfig.UseOfMFC == UseOfMFC.Shared) {
options.AppendFormat("/d \"_AFXDLL\"");
}
if (options.Length > 0) {
rcTask.Options = options.ToString();
}
// Compile each resource file
foreach (string rcFile in fileNames) {
rcTask.OutputFile = new FileInfo(GetResourceOutputFile(rcFile, fileConfig));
rcTask.RcFile = new FileInfo(FileUtils.CombinePaths(ProjectDirectory.FullName, rcFile));
// execute the task
ExecuteInProjectDirectory(rcTask);
}
}
///
/// Build Interface Definition Language files for the given
/// configuration.
///
/// The IDL files to build.
/// The project configuration.
/// The build configuration.
///
/// TODO: refactor this as we should always get only one element in the
/// list. Each IDL file should be built
/// with its own file configuration.
///
private void BuildIDLFiles(ArrayList fileNames, VcProjectConfiguration projectConfig, VcConfigurationBase fileConfig) {
// create instance of MIDL task
MidlTask midlTask = new MidlTask();
// inherit project from solution task
midlTask.Project = SolutionTask.Project;
// Set the base directory
midlTask.BaseDirectory = ProjectDirectory;
// inherit namespace manager from solution task
midlTask.NamespaceManager = SolutionTask.NamespaceManager;
// parent is solution task
midlTask.Parent = SolutionTask;
// inherit verbose setting from solution task
midlTask.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
midlTask.InitializeTaskConfiguration();
// set parent of child elements
midlTask.IncludeDirs.Parent = midlTask;
// inherit project from solution task for child elements
midlTask.IncludeDirs.Project = midlTask.Project;
// set namespace manager of child elements
midlTask.IncludeDirs.NamespaceManager = midlTask.NamespaceManager;
// set base directories
midlTask.IncludeDirs.BaseDirectory = ProjectDirectory;
// If outputDirectory is not supplied in the configuration, assume
// it's the project directory
string outputDirectory = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "OutputDirectory");
if (String.IsNullOrEmpty(outputDirectory)) {
outputDirectory = ProjectDirectory.FullName;
} else {
outputDirectory = FileUtils.CombinePaths(ProjectDirectory.FullName,
outputDirectory);
}
// ensure output directory exists
if (!Directory.Exists(outputDirectory)) {
Directory.CreateDirectory(outputDirectory);
}
midlTask.Arguments.Add(new Argument("/out"));
midlTask.Arguments.Add(new Argument(outputDirectory));
string typeLibraryName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool,
"TypeLibraryName", "$(IntDir)/$(ProjectName).tlb");
if (!String.IsNullOrEmpty(typeLibraryName)) {
midlTask.Tlb = new FileInfo(FileUtils.CombinePaths(outputDirectory,
typeLibraryName));
// ensure tlb directory exists
if (!midlTask.Tlb.Directory.Exists) {
midlTask.Tlb.Directory.Create();
midlTask.Tlb.Directory.Refresh();
}
}
string proxyFileName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "ProxyFileName");
if (!String.IsNullOrEmpty(proxyFileName)) {
midlTask.Proxy = new FileInfo(FileUtils.CombinePaths(outputDirectory,
proxyFileName));
// ensure proxy directory exists
if (!midlTask.Proxy.Directory.Exists) {
midlTask.Proxy.Directory.Create();
midlTask.Proxy.Directory.Refresh();
}
}
string interfaceIdentifierFileName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "InterfaceIdentifierFileName");
if (!String.IsNullOrEmpty(interfaceIdentifierFileName)) {
midlTask.Iid = new FileInfo(FileUtils.CombinePaths(outputDirectory,
interfaceIdentifierFileName));
// ensure IID directory exists
if (!midlTask.Iid.Directory.Exists) {
midlTask.Iid.Directory.Create();
midlTask.Iid.Directory.Refresh();
}
}
string dllDataFileName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "DLLDataFileName");
if (!String.IsNullOrEmpty(dllDataFileName)) {
midlTask.DllData = new FileInfo(FileUtils.CombinePaths(outputDirectory,
dllDataFileName));
// ensure DllData directory exists
if (!midlTask.DllData.Directory.Exists) {
midlTask.DllData.Directory.Create();
midlTask.DllData.Directory.Refresh();
}
}
string headerFileName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "HeaderFileName");
if (!String.IsNullOrEmpty(headerFileName)) {
midlTask.Header = new FileInfo(FileUtils.CombinePaths(outputDirectory,
headerFileName));
// ensure Header directory exists
if (!midlTask.Header.Directory.Exists) {
midlTask.Header.Directory.Create();
midlTask.Header.Directory.Refresh();
}
}
string preprocessorDefs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.MIDLTool, "PreprocessorDefinitions");
if (!String.IsNullOrEmpty(preprocessorDefs)) {
foreach (string preprocessorDef in preprocessorDefs.Split(';')) {
if (preprocessorDef.Length == 0) {
continue;
}
Option op = new Option();
op.OptionName = preprocessorDef;
midlTask.Defines.Add(op);
}
}
string undefinePreprocessorDefs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.MIDLTool, "UndefinePreprocessorDefinitions");
if (!String.IsNullOrEmpty(undefinePreprocessorDefs)) {
foreach (string undefinePreprocessorDef in undefinePreprocessorDefs.Split(';')) {
if (undefinePreprocessorDef.Length == 0) {
continue;
}
Option op = new Option();
op.OptionName = undefinePreprocessorDef;
midlTask.Undefines.Add(op);
}
}
string additionalIncludeDirs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.MIDLTool, "AdditionalIncludeDirectories");
if (!String.IsNullOrEmpty(additionalIncludeDirs)) {
foreach (string includeDir in additionalIncludeDirs.Split(';')) {
if (includeDir.Length == 0) {
continue;
}
midlTask.IncludeDirs.DirectoryNames.Add(FileUtils.CombinePaths(
ProjectDirectory.FullName, CleanPath(includeDir)));
}
}
string cPreprocessOptions = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.MIDLTool, "CPreprocessOptions");
if (!String.IsNullOrEmpty(cPreprocessOptions)) {
foreach (string cPreprocessOption in cPreprocessOptions.Split(';')) {
if (cPreprocessOption.Length == 0) {
continue;
}
midlTask.Arguments.Add(new Argument(string.Format("/cpp_opt\"{0}\"", cPreprocessOption)));
}
}
Hashtable midlArgs = fileConfig.GetToolArguments(VcConfigurationBase.MIDLTool, _midlArgMap);
foreach (string key in midlArgs.Keys) {
switch (key) {
case "TargetEnvironment":
midlTask.Env = (string) midlArgs[key];
break;
case "DefaultCharType":
midlTask.Char = (string) midlArgs[key];
break;
default:
Argument midlArg = new Argument();
midlArg.Line = (string) midlArgs[key];
midlTask.Arguments.Add(midlArg);
break;
}
}
// Compile each idl file
foreach (string idlFile in fileNames) {
midlTask.Filename = new FileInfo(FileUtils.CombinePaths(
ProjectDirectory.FullName, idlFile));
// execute the task
ExecuteInProjectDirectory(midlTask);
}
}
private bool RunCustomBuildStep(Configuration solutionConfiguration, VcProjectConfiguration projectConfig) {
// check if a custom build step is configured
string commandLine = projectConfig.GetToolSetting(VcConfigurationBase.CustomBuildTool,
"CommandLine");
if (String.IsNullOrEmpty(commandLine)) {
return true;
}
DateTime oldestOutputFile = DateTime.MinValue;
string outputs = projectConfig.GetToolSetting(VcConfigurationBase.CustomBuildTool,
"Outputs");
if (!String.IsNullOrEmpty(outputs)) {
foreach (string output in outputs.Split(';')) {
if (output.Length == 0) {
continue;
}
string outputFile = Path.Combine (ProjectDirectory.FullName,
output);
if (File.Exists(outputFile)) {
DateTime lastWriteTime = File.GetLastWriteTime(outputFile);
if (lastWriteTime < oldestOutputFile || oldestOutputFile == DateTime.MinValue) {
oldestOutputFile = lastWriteTime;
}
}
}
}
bool runCustomBuildStep = false;
// when at least one of the output files of the custom build step
// does not exist or is older than the project output file, then
// the custom build step must be executed
string projectOutputFile = GetOutputPath(solutionConfiguration);
if (projectOutputFile != null && File.Exists (projectOutputFile)) {
DateTime lastWriteTime = File.GetLastWriteTime(projectOutputFile);
if (lastWriteTime > oldestOutputFile) {
runCustomBuildStep = true;
}
}
// if one of the additional dependencies was updated after the oldest
// output file of the custom build step, then the custom build step
// must also be executed
if (!runCustomBuildStep) {
string additionalDependencies = projectConfig.GetToolSetting(
VcConfigurationBase.CustomBuildTool, "AdditionalDependencies");
if (!String.IsNullOrEmpty(additionalDependencies)) {
foreach (string dependency in additionalDependencies.Split(';')) {
if (dependency.Length == 0) {
continue;
}
string dependencyFile = Path.Combine (ProjectDirectory.FullName,
dependency);
if (File.Exists (dependencyFile)) {
DateTime lastWriteTime = File.GetLastWriteTime(dependencyFile);
if (lastWriteTime > oldestOutputFile) {
runCustomBuildStep = true;
break;
}
}
}
}
}
if (!runCustomBuildStep) {
return true;
}
string description = projectConfig.GetToolSetting(VcConfigurationBase.CustomBuildTool,
"Description", "Performing Custom Build Step");
Log(Level.Info, description);
return ExecuteBuildEvent("Custom-Build", commandLine, projectConfig);
}
private void RunLibrarian(VcProjectConfiguration projectConfig) {
// check if there's anything to do
if (projectConfig.ObjFiles.Count == 0) {
Log(Level.Debug, "No files to compile.");
return;
}
// create instance of Lib task
LibTask libTask = new LibTask();
// inherit project from solution task
libTask.Project = SolutionTask.Project;
// inherit namespace manager from solution task
libTask.NamespaceManager = SolutionTask.NamespaceManager;
// parent is solution task
libTask.Parent = SolutionTask;
// inherit verbose setting from solution task
libTask.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
libTask.InitializeTaskConfiguration();
// set parent of child elements
libTask.Sources.Parent = libTask;
// inherit project from solution task for child elements
libTask.Sources.Project = libTask.Project;
// inherit namespace manager from parent
libTask.Sources.NamespaceManager = libTask.NamespaceManager;
libTask.OutputFile = new FileInfo(projectConfig.OutputPath);
// Additional Library Directory
string addLibDirs = projectConfig.GetToolSetting(VcConfigurationBase.LibTool, "AdditionalLibraryDirectories");
if (!String.IsNullOrEmpty(addLibDirs)) {
foreach (string addLibDir in addLibDirs.Split(',', ';')) {
if (addLibDir.Length == 0) {
continue;
}
libTask.LibDirs.DirectoryNames.Add(addLibDir);
}
}
// Additional Dependencies
string addDeps = projectConfig.GetToolSetting(VcConfigurationBase.LibTool, "AdditionalDependencies");
if (!String.IsNullOrEmpty(addDeps)) {
int insertedDeps = 0;
foreach (string addDep in addDeps.Split(' ')) {
if (Path.GetExtension(addDep) == ".obj") {
projectConfig.ObjFiles.Insert(insertedDeps++, addDep);
} else {
libTask.Sources.FileNames.Add(addDep);
}
}
}
foreach (string objFile in projectConfig.ObjFiles) {
libTask.Sources.FileNames.Add(objFile);
}
// Module Definition File Name
string moduleDefinitionFile = projectConfig.GetToolSetting(VcConfigurationBase.LibTool, "ModuleDefinitionFile");
if (!String.IsNullOrEmpty(moduleDefinitionFile)) {
libTask.ModuleDefinitionFile = new FileInfo(FileUtils.CombinePaths(
ProjectDirectory.FullName, moduleDefinitionFile));
}
// Ignore All Default Libraries
string ignoreAllDefaultLibraries = projectConfig.GetToolSetting(VcConfigurationBase.LibTool, "IgnoreAllDefaultLibraries");
if (string.Compare(ignoreAllDefaultLibraries, "TRUE", true, CultureInfo.InvariantCulture) == 0) {
libTask.Options = "/NODEFAULTLIB";
}
// Ignore Specific Libraries
string ignoreDefaultLibraries = projectConfig.GetToolSetting(VcConfigurationBase.LibTool, "IgnoreDefaultLibraryNames");
if (!String.IsNullOrEmpty(ignoreDefaultLibraries)) {
foreach (string ignoreLibrary in ignoreDefaultLibraries.Split(';')) {
libTask.IgnoreLibraries.Add(new Library(ignoreLibrary));
}
}
// Export Named Functions
// TODO
// Forced Symbol References
string symbolReferences = projectConfig.GetToolSetting(VcConfigurationBase.LibTool,
"ForceSymbolReferences");
if (!String.IsNullOrEmpty(symbolReferences)) {
foreach (string symbol in symbolReferences.Split(';')) {
libTask.Symbols.Add(new Symbol(symbol));
}
}
// execute the task
ExecuteInProjectDirectory(libTask);
}
private void RunLinker(Configuration solutionConfiguration) {
const string noinherit = "$(noinherit)";
// obtain project configuration (corresponding with solution configuration)
VcProjectConfiguration projectConfig = (VcProjectConfiguration) BuildConfigurations[solutionConfiguration];
// check if linking needs to be performed
if (projectConfig.ObjFiles.Count == 0) {
Log(Level.Debug, "No files to link.");
return;
}
// create instance of Link task
LinkTask linkTask = new LinkTask();
// inherit project from solution task
linkTask.Project = SolutionTask.Project;
// inherit namespace manager from solution task
linkTask.NamespaceManager = SolutionTask.NamespaceManager;
// parent is solution task
linkTask.Parent = SolutionTask;
// inherit verbose setting from solution task
linkTask.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
linkTask.InitializeTaskConfiguration();
// set parent of child elements
linkTask.Sources.Parent = linkTask;
linkTask.LibDirs.Parent = linkTask;
linkTask.Modules.Parent = linkTask;
linkTask.EmbeddedResources.Project = linkTask.Project;
// inherit project from solution task for child elements
linkTask.Sources.Project = linkTask.Project;
linkTask.LibDirs.Project = linkTask.Project;
linkTask.Modules.Project = linkTask.Project;
linkTask.EmbeddedResources.Project = linkTask.Project;
// inherit namespace manager from parent
linkTask.Sources.NamespaceManager = linkTask.NamespaceManager;
linkTask.LibDirs.NamespaceManager = linkTask.NamespaceManager;
linkTask.Modules.NamespaceManager = linkTask.NamespaceManager;
linkTask.EmbeddedResources.NamespaceManager = linkTask.NamespaceManager;
// set base directory of filesets
linkTask.Sources.BaseDirectory = ProjectDirectory;
linkTask.LibDirs.BaseDirectory = ProjectDirectory;
linkTask.Modules.BaseDirectory = ProjectDirectory;
linkTask.EmbeddedResources.BaseDirectory = ProjectDirectory;
string addDeps = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "AdditionalDependencies");
if (!String.IsNullOrEmpty(addDeps)) {
// only include default libraries if noinherit is not set
if (addDeps.ToLower(CultureInfo.InvariantCulture).IndexOf(noinherit) == -1) {
foreach (string defaultLib in _defaultLibraries) {
linkTask.Sources.FileNames.Add(defaultLib);
}
} else {
addDeps = addDeps.Remove(addDeps.ToLower(CultureInfo.InvariantCulture).IndexOf(noinherit), noinherit.Length);
}
foreach (string addDep in addDeps.Split(' ')) {
if (Path.GetExtension(addDep) == ".obj") {
// skip obj files are these are handled in
// VcProjectConfiguration
continue;
}
linkTask.Sources.FileNames.Add(addDep);
}
} else {
// always include default libraries if no additional dependencies
// are specified
foreach (string defaultLib in _defaultLibraries) {
linkTask.Sources.FileNames.Add(defaultLib);
}
}
string delayLoadedDlls = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "DelayLoadDLLs");
if (!String.IsNullOrEmpty(delayLoadedDlls)) {
foreach (string dll in delayLoadedDlls.Split(';')) {
linkTask.DelayLoadedDlls.FileNames.Add(dll);
}
}
foreach (string objFile in projectConfig.ObjFiles) {
linkTask.Sources.FileNames.Add(objFile);
}
// add output generated by referenced projects and explicit project
// dependencies
ProjectBaseCollection projectDependencies = GetVcProjectDependencies();
foreach (VcProject vcProject in projectDependencies) {
VcProjectConfiguration vcProjectConfig = vcProject.BuildConfigurations[
solutionConfiguration] as VcProjectConfiguration;
switch (vcProjectConfig.Type) {
case VcProjectConfiguration.ConfigurationType.Application:
case VcProjectConfiguration.ConfigurationType.DynamicLibrary:
FileInfo dependencyImportLibrary = vcProjectConfig.LinkerConfiguration.ImportLibrary;
if (dependencyImportLibrary != null) {
linkTask.Sources.FileNames.Add(
dependencyImportLibrary.FullName);
}
break;
case VcProjectConfiguration.ConfigurationType.StaticLibrary:
linkTask.Sources.FileNames.Add(vcProjectConfig.OutputPath);
break;
}
}
linkTask.OutputFile = new FileInfo(projectConfig.OutputPath);
// ensure directory exists
if (!linkTask.OutputFile.Directory.Exists) {
linkTask.OutputFile.Directory.Create();
linkTask.OutputFile.Directory.Refresh();
}
// generation of debug information
linkTask.Debug = bool.Parse(projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "GenerateDebugInformation", "FALSE"));
string pdbFile = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "ProgramDatabaseFile");
// use default value if pdb was not explicitly disabled (by setting it to empty string)
if (pdbFile == null && linkTask.Debug) {
pdbFile = projectConfig.ExpandMacros("$(OutDir)/$(ProjectName).pdb");
}
if (!String.IsNullOrEmpty(pdbFile)) {
if (OutputDir != null) {
pdbFile = FileUtils.CombinePaths(OutputDir.FullName, Path.GetFileName(pdbFile));
} else {
pdbFile = FileUtils.CombinePaths(ProjectDirectory.FullName, pdbFile);
}
linkTask.ProgramDatabaseFile = new FileInfo(pdbFile);
// ensure directory exists
if (!linkTask.ProgramDatabaseFile.Directory.Exists) {
linkTask.ProgramDatabaseFile.Directory.Create();
linkTask.ProgramDatabaseFile.Directory.Refresh();
}
}
// generation of import library
FileInfo importLibrary = projectConfig.LinkerConfiguration.ImportLibrary;
if (importLibrary != null) {
Argument importLibraryArg = new Argument();
importLibraryArg.Line = "/IMPLIB:" + LinkTask.QuoteArgumentValue(
importLibrary.FullName);
linkTask.Arguments.Add(importLibraryArg);
// ensure directory exists
if (!importLibrary.Directory.Exists) {
importLibrary.Directory.Create();
importLibrary.Directory.Refresh();
}
}
// Ignore Specific Libraries
string ignoreDefaultLibraries = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool,
"IgnoreDefaultLibraryNames");
if (!String.IsNullOrEmpty(ignoreDefaultLibraries)) {
foreach (string ignoreLibrary in ignoreDefaultLibraries.Split(';')) {
linkTask.IgnoreLibraries.Add(new Library(ignoreLibrary));
}
}
// Forced Symbol References
string symbolReferences = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool,
"ForceSymbolReferences");
if (!String.IsNullOrEmpty(symbolReferences)) {
foreach (string symbol in symbolReferences.Split(';')) {
linkTask.Symbols.Add(new Symbol(symbol));
}
}
// generation of map file during linking
bool generateMapFile = bool.Parse(projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "GenerateMapFile", "FALSE"));
if (generateMapFile) {
Argument mapArg = new Argument();
string mapFileName = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "MapFileName");
if (!String.IsNullOrEmpty(mapFileName)) {
mapArg.Line = "/MAP:" + LinkTask.QuoteArgumentValue(mapFileName);;
} else {
mapArg.Line = "/MAP";
}
linkTask.Arguments.Add(mapArg);
}
// total heap allocation size
string heapReserveSize = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "HeapReserveSize");
if (!String.IsNullOrEmpty(heapReserveSize)) {
Argument heapArg = new Argument();
string heapCommitSize = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "HeapCommitSize");
if (!String.IsNullOrEmpty(heapCommitSize)) {
heapArg.Line = string.Format(CultureInfo.InvariantCulture,
"/HEAP:{0},{1}", heapReserveSize, heapCommitSize);
} else {
heapArg.Line = "/HEAP:" + heapReserveSize;
}
linkTask.Arguments.Add(heapArg);
}
// total stack allocation size
string stackReserveSize = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "StackReserveSize");
if (!String.IsNullOrEmpty(stackReserveSize)) {
Argument stackArg = new Argument();
string stackCommitSize = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "StackCommitSize");
if (!String.IsNullOrEmpty(stackCommitSize)) {
stackArg.Line = string.Format(CultureInfo.InvariantCulture,
"/STACK:{0},{1}", stackReserveSize, stackCommitSize);
} else {
stackArg.Line = "/STACK:" + stackReserveSize;
}
linkTask.Arguments.Add(stackArg);
}
if (projectConfig.Type == VcProjectConfiguration.ConfigurationType.DynamicLibrary) {
linkTask.Arguments.Add(new Argument("/DLL"));
}
string addLibDirs = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "AdditionalLibraryDirectories");
if (!String.IsNullOrEmpty(addLibDirs)) {
foreach (string addLibDir in addLibDirs.Split(',', ';')) {
if (addLibDir.Length == 0) {
continue;
}
linkTask.LibDirs.DirectoryNames.Add(addLibDir);
}
}
// links to modules
string modules = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "AddModuleNamesToAssembly");
if (!String.IsNullOrEmpty(modules)) {
foreach (string module in modules.Split(';')) {
linkTask.Modules.FileNames.Add(module);
}
}
// embedded resources
string embeddedResources = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "EmbedManagedResourceFile");
if (!String.IsNullOrEmpty(embeddedResources)) {
foreach (string embeddedResource in embeddedResources.Split(';')) {
linkTask.EmbeddedResources.FileNames.Add(embeddedResource);
}
}
Hashtable linkerArgs = projectConfig.GetToolArguments(VcConfigurationBase.LinkerTool, _linkerArgMap);
foreach (string arg in linkerArgs.Values) {
Argument linkArg = new Argument();
linkArg.Line = (string) arg;
linkTask.Arguments.Add(linkArg);
}
string addOptions = projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool, "AdditionalOptions");
if (!String.IsNullOrEmpty(addOptions)) {
using (StringReader reader = new StringReader(addOptions)) {
string addOptionsLine = reader.ReadLine();
while (addOptionsLine != null) {
foreach (string addOption in addOptionsLine.Split(' ')) {
linkTask.Arguments.Add(new Argument(addOption));
}
addOptionsLine = reader.ReadLine();
}
}
}
if (projectConfig.WholeProgramOptimization) {
linkTask.Arguments.Add(new Argument("/LTCG"));
}
// execute the task
ExecuteInProjectDirectory(linkTask);
}
private void ExecuteInProjectDirectory(Task task) {
string oldBaseDir = SolutionTask.Project.BaseDirectory;
SolutionTask.Project.BaseDirectory = ProjectDirectory.FullName;
try {
// increment indentation level
task.Project.Indent();
// execute task
task.Execute();
} finally {
// restore original base directory
SolutionTask.Project.BaseDirectory = oldBaseDir;
// restore indentation level
task.Project.Unindent();
}
}
///
/// Merges the specified tool setting of
/// with .
///
///
/// The merge is suppressed when the flag $(noinherit) is defined in
/// .
///
private string MergeToolSetting(VcProjectConfiguration projectConfig, VcConfigurationBase fileConfig, string tool, string setting) {
const string noinherit = "$(noinherit)";
// get tool setting from either the file configuration or project
// configuration (if setting is not defined on file configuration)
string settingValue = fileConfig.GetToolSetting(tool, setting);
if (settingValue != null) {
if (settingValue.ToLower(CultureInfo.InvariantCulture).IndexOf(noinherit) == -1) {
// only add project-level setting to value if noherit if
// "fileConfig" is not actually the project config
if (!object.ReferenceEquals(projectConfig, fileConfig)) {
string baseSettingValue = projectConfig.GetToolSetting(tool, setting);
if (!String.IsNullOrEmpty(baseSettingValue)) {
settingValue += ";" + baseSettingValue;
}
}
} else {
settingValue = settingValue.Remove(settingValue.ToLower(CultureInfo.InvariantCulture).IndexOf(noinherit), noinherit.Length);
}
} else {
// if settingValue is null, then its not defined in neither the
// file nor the project configuration
return null;
}
// individual values are separated by ';'
string[] values = settingValue.Split(';');
// holds filtered setting value
settingValue = string.Empty;
// filter duplicate setting values
Hashtable filteredValues = CollectionsUtil.CreateCaseInsensitiveHashtable(values.Length);
foreach (string value in values) {
if (!filteredValues.ContainsKey(value)) {
filteredValues.Add(value, null);
if (settingValue.Length != 0) {
settingValue += ';';
}
settingValue += value;
}
}
return settingValue;
}
private bool PreBuild(VcProjectConfiguration projectConfig) {
// check if the build event should be executed
string excludedFromBuild = projectConfig.GetToolSetting(VcConfigurationBase.PreBuildEventTool,
"ExcludedFromBuild");
if (excludedFromBuild != null) {
if (string.Compare(excludedFromBuild.Trim(), "true", true, CultureInfo.InvariantCulture) == 0) {
return true;
}
}
string commandLine = projectConfig.GetToolSetting(VcConfigurationBase.PreBuildEventTool,
"CommandLine");
if (!String.IsNullOrEmpty(commandLine)) {
Log(Level.Info, "Performing Pre-Build Event...");
return ExecuteBuildEvent("Pre-Build", commandLine, projectConfig);
}
return true;
}
private bool PostBuild(VcProjectConfiguration projectConfig) {
// check if the build event should be executed
string excludedFromBuild = projectConfig.GetToolSetting(VcConfigurationBase.PostBuildEventTool,
"ExcludedFromBuild");
if (excludedFromBuild != null) {
if (string.Compare(excludedFromBuild.Trim(), "true", true, CultureInfo.InvariantCulture) == 0) {
return true;
}
}
string commandLine = projectConfig.GetToolSetting(VcConfigurationBase.PostBuildEventTool,
"CommandLine");
if (!String.IsNullOrEmpty(commandLine)) {
Log(Level.Info, "Performing Post-Build Event...");
return ExecuteBuildEvent("Post-Build", commandLine, projectConfig);
}
return true;
}
private bool PreLink(VcProjectConfiguration projectConfig) {
// check if the build event should be executed
string excludedFromBuild = projectConfig.GetToolSetting(VcConfigurationBase.PreLinkEventTool,
"ExcludedFromBuild");
if (excludedFromBuild != null) {
if (string.Compare(excludedFromBuild.Trim(), "true", true, CultureInfo.InvariantCulture) == 0) {
return true;
}
}
string commandLine = projectConfig.GetToolSetting(VcConfigurationBase.PreLinkEventTool,
"CommandLine");
if (!String.IsNullOrEmpty(commandLine)) {
Log(Level.Info, "Performing Pre-Link Event...");
return ExecuteBuildEvent("Pre-Link", commandLine, projectConfig);
}
return true;
}
private bool ExecuteBuildEvent(string buildEvent, string buildCommandLine, ConfigurationBase config) {
string batchFile = null;
try {
// get unique temp file name to write command line of build event to
batchFile = Path.GetTempFileName();
// remove temp file
File.Delete(batchFile);
// change extension to .bat
batchFile = Path.ChangeExtension(batchFile, ".bat");
// execute the build event
return base.ExecuteBuildEvent(buildEvent, buildCommandLine, batchFile,
ProjectDirectory.FullName, config);
} finally {
if (batchFile != null && File.Exists(batchFile)) {
File.Delete(batchFile);
}
}
}
///
/// Gets the absolute path to the object file or directory.
///
/// The build configuration
///
/// The absolute path to the object file or directory, or
///
///
/// We use an absolute path for the object file, otherwise
/// <cl> assumes a location relative to the output
/// directory - not the project directory.
///
private string GetObjectFile(VcConfigurationBase fileConfig) {
string objectFile = fileConfig.GetToolSetting("VCCLCompilerTool",
"ObjectFile", "$(IntDir)/");
if (!String.IsNullOrEmpty(objectFile)) {
return FileUtils.CombinePaths(ProjectDirectory.FullName,
objectFile);
}
return null;
}
private ProjectBaseCollection GetVcProjectDependencies() {
ProjectBaseCollection vcProjectDependencies = new ProjectBaseCollection();
foreach (ProjectBase projectDependency in ProjectDependencies) {
if (projectDependency is VcProject) {
vcProjectDependencies.Add(projectDependency);
}
}
foreach (ReferenceBase reference in References) {
// skip non-project reference
ProjectReferenceBase projectReference = reference as ProjectReferenceBase;
if (projectReference == null) {
continue;
}
// check if we're dealing with reference to VC++ project
VcProject vcProject = projectReference.Project as VcProject;
if (vcProject == null) {
continue;
}
// skip projects that have already been added to collection
if (vcProjectDependencies.Contains(vcProject)) {
continue;
}
vcProjectDependencies.Add(vcProject);
}
return vcProjectDependencies;
}
#endregion Private Instance Methods
#region Public Static Methods
public static string LoadGuid(XmlElement xmlDefinition) {
return xmlDefinition.GetAttribute("ProjectGUID");
}
///
/// Returns a value indicating whether the project represented by the
/// specified XML fragment is supported by .
///
/// XML fragment representing the project to check.
///
/// if supports the
/// specified project; otherwise, .
///
///
///
/// A project is identified as as Visual C++ project, if the XML
/// fragment at least has the following information:
///
///
///
///
/// ]]>
///
///
public static bool IsSupported(XmlElement docElement) {
if (docElement == null) {
return false;
}
if (docElement.Name != "VisualStudioProject") {
return false;
}
XmlAttribute projectTypeAttribute = docElement.Attributes["ProjectType"];
if (projectTypeAttribute == null || projectTypeAttribute.Value != "Visual C++") {
return false;
}
//MAL 2007/12/20
//this is double check - really needed? In addition, when version check fails, it gives odd error.
//2nd check is made in DetermineProductVersion (called from ProjectBase constructor)
//try {
// GetProductVersion(docElement);
// // no need to perform version check here as this is done in
// // GetProductVersion
//} catch {
// // product version could not be determined or is not supported
// return false;
//}
return true;
}
#endregion Public Static Methods
#region Private Static Methods
///
/// Removes leading and trailing quotes from the specified path.
///
/// The path to clean.
private static string CleanPath(string path) {
string cleanedPath = path.TrimStart('\"');
return cleanedPath.TrimEnd('\"');
}
///
/// Returns the Visual Studio product version of the specified project
/// XML fragment.
///
/// XML fragment representing the project to check.
///
/// The Visual Studio product version of the specified project XML
/// fragment.
///
///
/// The product version could not be determined.
/// -or-
/// The product version is not supported.
///
private static ProductVersion GetProductVersion(XmlElement docElement) {
if (docElement == null) {
throw new ArgumentNullException("docElement");
}
XmlAttribute productVersionAttribute = docElement.Attributes["Version"];
if (productVersionAttribute == null) {
throw new BuildException("The \"Version\" attribute is"
+ " missing from the node.",
Location.UnknownLocation);
}
// check if we're dealing with a valid version number
Version productVersion = null;
try {
string ver = productVersionAttribute.Value;
ver = ver.Replace(',', '.'); //Whidbey (8,00) and Orcas (9,00) are using comma instead of point
productVersion = new Version(ver);
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"The value of the \"Version\" attribute ({0}) is not a valid"
+ " version string.", productVersionAttribute.Value),
Location.UnknownLocation, ex);
}
switch(productVersion.Major) {
case 7:
switch (productVersion.Minor) {
case 0:
return ProductVersion.Rainier;
case 10:
return ProductVersion.Everett;
}
break;
case 8:
return ProductVersion.Whidbey;
case 9:
return ProductVersion.Orcas;
}
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Visual Studio version \"{0}\" is not supported.",
productVersion.ToString()), Location.UnknownLocation);
}
#endregion Private Static Methods
#region Private Instance Fields
private readonly string _name;
private readonly string _projectPath;
private string _guid;
private readonly ArrayList _references;
private readonly VcArgumentMap _clArgMap;
private readonly VcArgumentMap _linkerArgMap;
private readonly VcArgumentMap _midlArgMap;
///
/// Holds the files included in the project.
///
///
///
/// For project files with no specific file configuration, the relative
/// path is added to the list.
///
///
/// For project files that have a specific file configuration, a
/// containing the
/// instance representing the file configurations is added.
///
///
private readonly ArrayList _projectFiles;
#endregion Private Instance Fields
#region Private Static Fields
private static string[] _defaultLibraries = new string[] {
"kernel32.lib", "user32.lib", "gdi32.lib", "winspool.lib", "comdlg32.lib",
"advapi32.lib", "shell32.lib", "ole32.lib", "oleaut32.lib", "uuid.lib",
"odbc32.lib", "odbccp32.lib"
};
#endregion Private Static Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/ConfigurationMap.cs 0000644 0001750 0001750 00000015002 11757302274 021250 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2008 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net.be)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
namespace NAnt.VSNet {
public sealed class ConfigurationMap : IDictionary, ICollection, IEnumerable {
#region Private Instance Fields
private readonly Hashtable _innerHash;
#endregion Private Instance Fields
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public ConfigurationMap() {
_innerHash = CollectionsUtil.CreateCaseInsensitiveHashtable();
}
///
/// Initializes a new instance of the
/// class with the specified initial capacity.
///
/// The appropriate number of entries that the can initially contain.
public ConfigurationMap(int capacity) {
_innerHash = CollectionsUtil.CreateCaseInsensitiveHashtable(capacity);
}
#endregion Public Instance Constructors
#region Internal Instance Properties
internal Hashtable InnerHash {
get { return _innerHash; }
}
#endregion Internal Instance Properties
#region Implementation of IDictionary
public ConfigurationMapEnumerator GetEnumerator() {
return new ConfigurationMapEnumerator(this);
}
IDictionaryEnumerator IDictionary.GetEnumerator() {
return GetEnumerator ();
}
IEnumerator IEnumerable.GetEnumerator() {
return GetEnumerator();
}
public void Remove(Configuration configuration) {
_innerHash.Remove(configuration);
}
void IDictionary.Remove(object key) {
Remove((Configuration) key);
}
public bool Contains(Configuration key) {
return _innerHash.Contains(key);
}
bool IDictionary.Contains(object key) {
return Contains((Configuration) key);
}
public void Clear() {
_innerHash.Clear();
}
public void Add(Configuration key, Configuration value) {
_innerHash.Add (key, value);
}
void IDictionary.Add(object key, object value) {
Add((Configuration) key, (Configuration) value);
}
public bool IsReadOnly {
get { return _innerHash.IsReadOnly; }
}
public Configuration this[Configuration key] {
get { return (Configuration) _innerHash[key]; }
set { _innerHash[key] = value; }
}
object IDictionary.this[object key] {
get { return this[(Configuration) key]; }
set { this[(Configuration) key] = (Configuration) value; }
}
public ICollection Values {
get { return _innerHash.Values; }
}
public ICollection Keys {
get { return _innerHash.Keys; }
}
public bool IsFixedSize {
get { return _innerHash.IsFixedSize; }
}
#endregion Implementation of IDictionary
#region Implementation of ICollection
void ICollection.CopyTo(Array array, int index) {
_innerHash.CopyTo(array, index);
}
public bool IsSynchronized {
get { return _innerHash.IsSynchronized; }
}
public int Count {
get { return _innerHash.Count; }
}
public object SyncRoot {
get { return _innerHash.SyncRoot; }
}
#endregion Implementation of ICollection
}
public class ConfigurationMapEnumerator : IDictionaryEnumerator {
#region Private Instance Fields
private readonly IDictionaryEnumerator _innerEnumerator;
#endregion Private Instance Fields
#region Internal Instance Constructors
internal ConfigurationMapEnumerator(ConfigurationMap enumerable) {
_innerEnumerator = enumerable.InnerHash.GetEnumerator();
}
#endregion Internal Instance Constructors
#region Implementation of IDictionaryEnumerator
public Configuration Key {
get { return (Configuration) _innerEnumerator.Key; }
}
object IDictionaryEnumerator.Key {
get { return Key; }
}
public Configuration Value {
get { return (Configuration) _innerEnumerator.Value; }
}
object IDictionaryEnumerator.Value {
get { return Value; }
}
public DictionaryEntry Entry {
get { return new DictionaryEntry (Key, Value); }
}
#endregion Implementation of IDictionaryEnumerator
#region Implementation of IEnumerator
public void Reset() {
_innerEnumerator.Reset();
}
public bool MoveNext() {
return _innerEnumerator.MoveNext();
}
object IEnumerator.Current {
get { return Current; }
}
public ConfigurationMapEntry Current {
get { return new ConfigurationMapEntry (Key, Value); }
}
#endregion Implementation of IEnumerator
}
public sealed class ConfigurationMapEntry {
private readonly Configuration _key;
private readonly Configuration _value;
internal ConfigurationMapEntry(Configuration key, Configuration value) {
_key = key;
_value = value;
}
public Configuration Key {
get { return _key; }
}
public Configuration Value {
get { return _value; }
}
}
}
nant-0.92-rc1/src/NAnt.VSNet/Everett/ 0000755 0001750 0001750 00000000000 11757310030 017061 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.VSNet/Everett/SolutionProvider.cs 0000644 0001750 0001750 00000004023 11757302274 022751 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Martin Aliger (martin_aliger@myrealbox.com)
using System;
using System.CodeDom.Compiler;
using System.Text.RegularExpressions;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Extensibility;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet.Everett {
internal class SolutionProvider : ISolutionBuildProvider {
#region Implementation of ISolutionBuildProvider
public int IsSupported(string fileContents) {
Regex reSolutionFormat = new Regex(@"^\s*Microsoft Visual Studio Solution File, Format Version\s+(?[0-9]+\.[0-9]+)", RegexOptions.Singleline);
MatchCollection matches = reSolutionFormat.Matches(fileContents);
if (matches.Count == 0)
return 0;
string formatVersion = matches[0].Groups["formatVersion"].Value;
if (formatVersion == "8.00")
return 10;
return 0;
}
public SolutionBase GetInstance(string solutionContent, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver) {
return new Solution(solutionContent, solutionTask, tfc, gacCache, refResolver);
}
#endregion Implementation of ISolutionBuildProvider
}
}
nant-0.92-rc1/src/NAnt.VSNet/Everett/Solution.cs 0000644 0001750 0001750 00000015201 11757302274 021236 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet.Everett {
///
/// Analyses Microsoft Visual Studio .NET 2003 (Everett) solution files.
///
internal class Solution : SolutionBase {
public Solution(string solutionContent, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver) : base(solutionTask, tfc, gacCache, refResolver) {
Regex reProjects = new Regex(@"Project\(\""(?\{.*?\})\"".*?\""(?.*?)\"".*?\""(?.*?)\"".*?\""(?.*?)\""(?[\s\S]*?)EndProject", RegexOptions.Multiline);
MatchCollection projectMatches = reProjects.Matches(solutionContent);
Hashtable explicitProjectDependencies = CollectionsUtil.CreateCaseInsensitiveHashtable();
foreach (Match projectMatch in projectMatches) {
string project = projectMatch.Groups["project"].Value;
string guid = projectMatch.Groups["guid"].Value;
// translate partial project path or URL to absolute path
string fullProjectPath = TranslateProjectPath(solutionTask.SolutionFile.DirectoryName,
project);
// check if project file actually exists
if (!System.IO.File.Exists(fullProjectPath)) {
throw CreateProjectDoesNotExistException(fullProjectPath);
}
bool isEnterpriseTemplateProject = ManagedProjectBase.IsEnterpriseTemplateProject(fullProjectPath);
if (isEnterpriseTemplateProject) {
RecursiveLoadTemplateProject(fullProjectPath);
} else {
// add project entry to collection
ProjectEntries.Add(new ProjectEntry(guid, fullProjectPath));
}
// set-up project dependencies
Regex reDependencies = new Regex(@"^\s+(?\{[0-9a-zA-Z]{8}-[0-9a-zA-Z]{4}-[0-9a-zA-Z]{4}-[0-9a-zA-Z]{4}-[0-9a-zA-Z]{12}\})\s+=\s+(?\{[0-9a-zA-Z]{8}-[0-9a-zA-Z]{4}-[0-9a-zA-Z]{4}-[0-9a-zA-Z]{4}-[0-9a-zA-Z]{12}\})", RegexOptions.Multiline);
MatchCollection dependencyMatches = reDependencies.Matches(projectMatch.Value);
foreach (Match dependencyMatch in dependencyMatches) {
string dependency = dependencyMatch.Groups["dep"].Value;
// bug #1534864: an Enterprise Template project actually
// defines dependencies for the projects it contains, and
// is not added as a project itself
//
// Note: for non-ET projects both the "guid" and "dep" group
// have the same value, which is the guid of the project
// that the project containing the dependencies section
// depends upon
string projectGuid = isEnterpriseTemplateProject ?
dependencyMatch.Groups["guid"].Value : guid;
if (!explicitProjectDependencies.ContainsKey(projectGuid)) {
explicitProjectDependencies[projectGuid] = CollectionsUtil.CreateCaseInsensitiveHashtable();
}
((Hashtable) explicitProjectDependencies[projectGuid])[dependency] = null;
}
// set-up project configuration
Regex reProjectBuildConfig = new Regex(@"^\s+" + guid + @"\.(?[^|]+)\|?(?[^\.]?)\.Build\.0\s*=\s* (?[^|]+)\|(?[\.\w ]+)\s*", RegexOptions.Multiline);
MatchCollection projectBuildMatches = reProjectBuildConfig.Matches(solutionContent);
ProjectEntry projectEntry = ProjectEntries [guid];
if (projectEntry == null) {
// TODO: determine if we should report an error if a build
// configuration is defined for a project that does not
// exist in the solution
continue;
}
// holds mapping between project configuration(s) and solution(s)
ConfigurationMap buildConfigurations = new ConfigurationMap(
projectBuildMatches.Count);
for (int i = 0; i < projectBuildMatches.Count; i++) {
Match projectBuildMatch = projectBuildMatches [i];
string solutionConfigName = projectBuildMatch.Groups["solutionConfiguration"].Value;
string solutionPlatform = projectBuildMatch.Groups["solutionPlatform"].Value;
string projectConfigName = projectBuildMatch.Groups["projectConfiguration"].Value;
string projectPlatform = projectBuildMatch.Groups["projectPlatform"].Value;
Configuration solutionConfig = new Configuration(
solutionConfigName, solutionPlatform);
Configuration projectConfig = new Configuration(
projectConfigName, projectPlatform);
buildConfigurations [solutionConfig] = projectConfig;
}
// add map to corresponding project entry
projectEntry.BuildConfigurations = buildConfigurations;
}
LoadProjectGuids(new ArrayList(solutionTask.Projects.FileNames), false);
LoadProjectGuids(new ArrayList(solutionTask.ReferenceProjects.FileNames), true);
LoadProjects(gacCache, refResolver, explicitProjectDependencies);
}
}
}
nant-0.92-rc1/src/NAnt.VSNet/VcArgumentMap.cs 0000644 0001750 0001750 00000067442 11757302274 020533 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Dmitry Jemerov
// Hani Atassi (haniatassi@users.sourceforge.net)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using NAnt.Core.Util;
using NAnt.VisualCpp.Tasks;
using NAnt.VisualCpp.Util;
namespace NAnt.VSNet {
///
/// A mapping from properties in the .vcproj file to command line arguments.
///
public class VcArgumentMap {
#region Public Instance Constructors
///
/// Initializes a new instance of the
/// class.
///
public VcArgumentMap() {
_htArgs = CollectionsUtil.CreateCaseInsensitiveHashtable();
}
#endregion Public Instance Constructors
#region Public Instance Methods
public void AddString(string propName, string argName) {
AddString(ArgGroup.Unassigned, propName, argName);
}
public void AddString(string propName, string argName, bool ignoreEmptyValue) {
AddString(ArgGroup.Unassigned, propName, argName, ignoreEmptyValue);
}
public void AddString(ArgGroup group, string propName, string argName) {
_htArgs [propName] = new VcStringArgument(group, argName);
}
public void AddString(ArgGroup group, string propName, string argName, bool ignoreEmptyValue) {
_htArgs [propName] = new VcStringArgument(group, argName, ignoreEmptyValue);
}
public void AddLinkerString(string propName, string argName) {
AddLinkerString(ArgGroup.Unassigned, propName, argName);
}
public void AddLinkerString(string propName, string argName, bool ignoreEmptyValue) {
AddLinkerString(ArgGroup.Unassigned, propName, argName, ignoreEmptyValue);
}
public void AddLinkerString(ArgGroup group, string propName, string argName) {
_htArgs [propName] = new LinkerStringArgument(group, argName);
}
public void AddLinkerString(ArgGroup group, string propName, string argName, bool ignoreEmptyValue) {
_htArgs [propName] = new LinkerStringArgument(group, argName, ignoreEmptyValue);
}
public void AddQuotedLinkerString(string propName, string argName) {
AddQuotedLinkerString(ArgGroup.Unassigned, propName, argName);
}
public void AddQuotedLinkerString(string propName, string argName, bool ignoreEmptyValue) {
AddQuotedLinkerString(ArgGroup.Unassigned, propName, argName, ignoreEmptyValue);
}
public void AddQuotedLinkerString(ArgGroup group, string propName, string argName) {
_htArgs [propName] = new QuotedLinkerStringArgument(group, argName);
}
public void AddQuotedLinkerString(ArgGroup group, string propName, string argName, bool ignoreEmptyValue) {
_htArgs [propName] = new QuotedLinkerStringArgument(group, argName, ignoreEmptyValue);
}
public void AddBool(string propName, string argName) {
AddBool(ArgGroup.Unassigned, propName, argName);
}
public void AddBool(string propName, string argName, string match) {
AddBool(ArgGroup.Unassigned, propName, argName, match);
}
public void AddBool(ArgGroup group, string propName, string argName) {
_htArgs [propName] = new VcBoolArgument(group, argName);
}
public void AddBool(ArgGroup group, string propName, string argName, string match) {
_htArgs [propName] = new VcBoolArgument(group, argName, match);
}
public void AddEnum(string propName, string argName, params string[] values) {
AddEnum(ArgGroup.Unassigned, propName, argName, values);
}
public void AddEnum(ArgGroup group, string propName, string argName, params string[] values) {
_htArgs [propName] = new VcEnumArgument(group, argName, values);
}
///
/// Gets the argument string corresponding with a configuration property
/// named with value .
/// An ignore mask can be used to eliminate some arguments from the search.
///
/// The name of the configuration property.
/// The value of the configuration property.
/// Specify any groups that needs to be ignored.
///
/// The argument string corresponding with a configuration property
/// named with value ,
/// or if no corresponding argument exists.
///
public string GetArgument(string propName, string propValue, ArgGroup useIgnoreGroup) {
VcArgument arg = (VcArgument) _htArgs [propName];
if (arg == null) {
return null;
}
if (arg.Group != ArgGroup.Unassigned && (arg.Group & useIgnoreGroup) != 0) {
return null;
}
return arg.MapValue(propValue);
}
#endregion Public Instance Methods
#region Public Static Methods
///
/// Creates a mapping between configuration properties for the Visual
/// C++ compiler and corresponding command-line arguments.
///
///
/// A mapping between configuration properties for the Visual C++
/// compiler and corresponding command-line arguments.
///
///
///
/// The following configuration properties are processed by
/// :
///
///
///
/// Category
/// Property
///
///
/// General
/// Addtional Include Directories (/I[path])
///
///
/// General
/// Resolve #using References (/AI[path])
///
///
/// Preprocessor
/// Preprocessor Definitions (/D[macro])
///
///
/// Code Generation
/// Enable C++ Exceptions (/EHsc)
///
///
/// Precompiled Headers
/// Create/Use Precompiled Header
///
///
/// Precompiled Headers
/// Create/Use PCH Through File
///
///
/// Precompiled Headers
/// Precompiled Header File
///
///
/// Output Files
/// Assembler Output
///
///
/// Output Files
/// ASM List Location
///
///
/// Browse Information
/// Enable Browse Information
///
///
/// Browse Information
/// Browse File
///
///
/// Advanced
/// Force Includes (/FI[name])
///
///
/// Advanced
/// Force #using (/FU[name])
///
///
/// Advanced
/// Undefine Preprocessor Definitions (/U[macro])
///
///
///
public static VcArgumentMap CreateCLArgumentMap() {
VcArgumentMap map = new VcArgumentMap();
// General
map.AddEnum("DebugInformationFormat", null, null, "/Z7", "/Zd", "/Zi", "/ZI");
map.AddEnum("CompileAsManaged", null, null, null, "/clr"); // file-level only
map.AddEnum("WarningLevel", null, "/W0", "/W1", "/W2", "/W3", "/W4");
map.AddBool("Detect64BitPortabilityProblems", "/Wp64");
map.AddBool("WarnAsError", "/WX");
// Optimization
map.AddEnum("Optimization", null, "/Od", "/O1", "/O2", "/Ox");
map.AddBool(ArgGroup.OptiIgnoreGroup, "GlobalOptimizations", "/Og");
map.AddEnum(ArgGroup.OptiIgnoreGroup, "InlineFunctionExpansion", null, "/Ob0", "/Ob1", "/Ob2");
map.AddBool(ArgGroup.OptiIgnoreGroup, "EnableIntrinsicFunctions", "/Oi");
map.AddBool("ImproveFloatingPointConsistency", "/Op");
map.AddEnum("FavorSizeOrSpeed", null, null, "/Ot", "/Os");
map.AddBool(ArgGroup.OptiIgnoreGroup, "OmitFramePointers", "/Oy");
map.AddBool("EnableFiberSafeOptimizations", "/GT");
map.AddEnum("OptimizeForProcessor", null, null, "/G5", "/G6", "/G7");
map.AddBool("OptimizeForWindowsApplication", "/GA");
// Preprocessor
map.AddBool("IgnoreStandardIncludePath", "/X");
map.AddEnum("GeneratePreprocessedFile", null, null, "/P", "/EP /P");
map.AddBool("KeepComments", "/C");
// Code Generation
map.AddBool(ArgGroup.OptiIgnoreGroup, "StringPooling", "/GF");
map.AddBool("MinimalRebuild", "/Gm");
map.AddBool("SmallerTypeCheck", "/RTCc");
map.AddEnum("BasicRuntimeChecks", null, null, "/RTCs", "/RTCu", "/RTC1");
map.AddEnum("RuntimeLibrary", null, "/MT", "/MTd", "/MD", "/MDd", "/ML", "/MLd");
map.AddEnum("StructMemberAlignment", null, null, "/Zp1", "/Zp2", "/Zp4", "/Zp8", "/Zp16");
map.AddBool("BufferSecurityCheck", "/GS");
map.AddBool(ArgGroup.OptiIgnoreGroup, "EnableFunctionLevelLinking", "/Gy");
map.AddEnum("EnableEnhancedInstructionSet", null, null, "/arch:SSE", "/arch:SSE2");
// Language
map.AddBool("DisableLanguageExtensions", "/Za");
map.AddBool("DefaultCharIsUnsigned", "/J");
map.AddBool("TreatWChar_tAsBuiltInType", "/Zc:wchar_t");
map.AddBool("ForceConformanceInForLoopScope", "/Zc:forScope");
map.AddBool("RuntimeTypeInfo", "/GR");
// Output Files
map.AddBool("ExpandAttributedSource", "/Fx");
map.AddEnum("AssemblerOutput", null, null, "/FA", "/FAcs", "/FAc", "/FAs");
// Advanced
map.AddEnum("CallingConvention", null, null, "/Gr", "/Gz");
map.AddEnum("CompileAs", null, null, "/TC", "/TP");
map.AddBool("ShowIncludes", "/showIncludes");
map.AddBool("UndefineAllPreprocessorDefinitions", "/u");
return map;
}
///
/// Creates a mapping between configuration properties for the Visual
/// C++ linker and corresponding command-line arguments.
///
///
/// A mapping between configuration properties for the Visual C++
/// linker and corresponding command-line arguments.
///
///
///
/// The following configuration properties are processed by
/// :
///
///
///
/// Category
/// Property
///
///
/// General
/// Output File (/OUT:[file])
///
///
/// General
/// Additional Library Directories (/LIBPATH:[dir])
///
///
/// Input
/// Additional Dependencies
///
///
/// Input
/// Add Module to Assembly (/ASSEMBLYMODULE:file)
///
///
/// Input
/// Embed Managed Resource File (/ASSEMBLYRESOURCE:file)
///
///
/// Debugging
/// Generate Debug Info (/DEBUG)
///
///
/// Debugging
/// Generate Program Database File (/PDB:name)
///
///
/// Debugging
/// Generate Map File (/MAP)
///
///
/// Debugging
/// Map File Name (/MAP:[filename])
///
///
/// System
/// Heap Reserve Size (/HEAP:reserve)
///
///
/// System
/// Heap Commit Size (/HEAP:reserve, commit)
///
///
/// System
/// Stack Reserve Size (/STACK:reserve)
///
///
/// System
/// Stack Commit Size (/STACK:reserve, commit)
///
///
///
/// The following configuration properties are ignored:
///
///
///
/// Category
/// Property
///
///
/// General
/// Show Progress (/VERBOSE, /VERBOSE:LIB)
///
///
/// General
/// Suppress Startup Banner (/NOLOGO)
///
///
///
/// Support for the following configuration properties still needs to
/// be implemented:
///
///
///
/// Category
/// Property
///
///
/// General
/// Ignore Import Library
///
///
/// General
/// Register Output
///
///
/// Input
/// Delay Loaded DLLs (/DELAYLOAD:[dll_name])
///
///
/// Embedded IDL
/// MIDL Commands (/MIDL:[file])
///
///
///
public static VcArgumentMap CreateLinkerArgumentMap() {
VcArgumentMap map = new VcArgumentMap();
// General
map.AddEnum("LinkIncremental", null, null, "/INCREMENTAL:NO", "/INCREMENTAL");
map.AddLinkerString("Version", "/VERSION:", true);
// Input
map.AddBool("IgnoreAllDefaultLibraries", "/NODEFAULTLIB");
map.AddQuotedLinkerString("ModuleDefinitionFile", "/DEF:", true);
// Debugging
map.AddQuotedLinkerString("StripPrivateSymbols", "/PDBSTRIPPED:", true);
map.AddBool("MapExports", "/MAPINFO:EXPORTS");
map.AddBool("MapLines", "/MAPINFO:LINES");
map.AddEnum("AssemblyDebug", null, null, "/ASSEMBLYDEBUG", "/ASSEMBLYDEBUG:DISABLE");
// System
map.AddEnum("SubSystem", "/SUBSYSTEM:", null, "CONSOLE", "WINDOWS");
map.AddEnum("LargeAddressAware", null, null, "/LARGEADDRESSAWARE:NO", "/LARGEADDRESSAWARE");
map.AddEnum("TerminalServerAware", null, null, "/TSAWARE:NO", "/TSAWARE");
map.AddBool("SwapRunFromCD", "/SWAPRUN:CD");
map.AddBool("SwapRunFromNet", "/SWAPRUN:NET");
// Optimization
map.AddEnum("OptimizeReferences", "/OPT:", null, "NOREF", "REF");
map.AddEnum("EnableCOMDATFolding", "/OPT:", null, "NOICF", "ICF");
map.AddEnum("OptimizeForWindows98", "/OPT:", null, "NOWIN98", "WIN98");
map.AddQuotedLinkerString("FunctionOrder", "/ORDER:", true);
// Embedded IDL
map.AddBool("IgnoreEmbeddedIDL", "/IGNOREIDL");
map.AddQuotedLinkerString("MergedIDLBaseFileName", "/IDLOUT:", true);
map.AddQuotedLinkerString("TypeLibraryFile", "/TLBOUT:", true);
map.AddLinkerString("TypeLibraryResourceID", "/TLBID:");
// Advanced
map.AddQuotedLinkerString("EntryPointSymbol", "/ENTRY:", true);
map.AddBool("ResourceOnlyDLL", "/NOENTRY");
map.AddBool("SetChecksum", "/RELEASE");
map.AddQuotedLinkerString("BaseAddress", "/BASE:", true);
map.AddEnum("FixedBaseAddress", null, null, "/FIXED:NO", "/FIXED");
map.AddBool("TurnOffAssemblyGeneration", "/NOASSEMBLY");
map.AddBool("SupportUnloadOfDelayLoadedDLL", "/DELAY:UNLOAD");
map.AddQuotedLinkerString("MergeSections", "/MERGE:", true);
map.AddEnum("TargetMachine", null, null, "/MACHINE:X86");
return map;
}
public static VcArgumentMap CreateMidlArgumentMap() {
VcArgumentMap map = new VcArgumentMap();
// General
map.AddBool("IgnoreStandardIncludePath", "/no_def_idir");
map.AddBool("MkTypLibCompatible", "/mktyplib203");
map.AddEnum("WarningLevel", null, "/W0", "/W1", "/W2", "/W3", "/W4");
map.AddBool("WarnAsError", "/WX");
map.AddEnum("DefaultCharType", null, "unsigned", "signed", "ascii7");
map.AddEnum("TargetEnvironment", null, null, "win32", "win64");
map.AddBool("GenerateStublessProxies", "/Oicf");
// Output
map.AddBool("GenerateTypeLibrary", "/notlb", "false");
// Advanced
map.AddEnum("EnableErrorChecks", "/error ", null, "none", "all");
map.AddBool("ErrorCheckAllocations", "/error allocation");
map.AddBool("ErrorCheckBounds", "/error bounds_check");
map.AddBool("ErrorCheckEnumRange", "/error enum");
map.AddBool("ErrorCheckRefPointers", "/error ref");
map.AddBool("ErrorCheckStubData", "/error stub_data");
map.AddBool("ValidateParameters", "/robust");
map.AddEnum("StructMemberAlignment", null, null, "/Zp1", "/Zp2", "/Zp4", "/Zp8");
return map;
}
#endregion Public Static Methods
#region Private Instance Fields
private Hashtable _htArgs;
#endregion Private Instance Fields
private abstract class VcArgument {
private string _name;
private ArgGroup _group;
protected VcArgument(ArgGroup group, string name) {
_name = name;
_group = group;
}
///
/// Gets the name of the command-line argument.
///
///
/// The name of the command-line argument.
///
public string Name {
get { return _name; }
}
public ArgGroup Group {
get { return _group; }
}
internal abstract string MapValue(string propValue);
protected string FormatOption(string value) {
if (_name == null) {
return value;
}
return _name + value;
}
}
private class VcStringArgument: VcArgument {
#region Private Instance Fields
private bool _ignoreEmptyValue;
#endregion Private Instance Fields
#region Internal Instance Constructors
internal VcStringArgument(ArgGroup group, string name): this(group, name, false) {
}
internal VcStringArgument(ArgGroup group, string name, bool ignoreEmptyValue): base(group, name) {
_ignoreEmptyValue = ignoreEmptyValue;
}
#endregion Internal Instance Constructors
#region Protected Instance Properties
protected bool IgnoreEmptyValue {
get { return _ignoreEmptyValue; }
}
#endregion Protected Instance Properties
#region Override implementation of VcArgument
internal override string MapValue(string propValue) {
if (IgnoreEmptyValue && String.IsNullOrEmpty(propValue)) {
return null;
}
return FormatOption(propValue);
}
#endregion Override implementation of VcArgument
}
///
/// Represents a command-line arguments of which the trailing backslashes
/// in the value should be duplicated.
///
private class LinkerStringArgument: VcStringArgument {
#region Internal Instance Constructors
internal LinkerStringArgument(ArgGroup group, string name): this(group, name, false) {
}
internal LinkerStringArgument(ArgGroup group, string name, bool ignoreEmptyValue): base(group, name, ignoreEmptyValue) {
}
#endregion Internal Instance Constructors
#region Override implementation of VcArgument
internal override string MapValue(string value) {
if (IgnoreEmptyValue && String.IsNullOrEmpty(value)) {
return null;
}
if (Name == null) {
return ArgumentUtils.DuplicateTrailingBackslash(value);
}
return Name + ArgumentUtils.DuplicateTrailingBackslash(value);
}
#endregion Override implementation of VcArgument
}
///
/// Represents a command-line argument of which the value should be
/// quoted, and of which trailing backslahes should be duplicated.
///
private class QuotedLinkerStringArgument: VcStringArgument {
#region Internal Instance Constructors
internal QuotedLinkerStringArgument(ArgGroup group, string name): this(group, name, false) {
}
internal QuotedLinkerStringArgument(ArgGroup group, string name, bool ignoreEmptyValue): base(group, name, ignoreEmptyValue) {
}
#endregion Internal Instance Constructors
#region Override implementation of VcArgument
internal override string MapValue(string value) {
if (IgnoreEmptyValue && String.IsNullOrEmpty(value)) {
return null;
}
if (Name == null) {
return LinkTask.QuoteArgumentValue(value);
}
return Name + LinkTask.QuoteArgumentValue(value);
}
#endregion Override implementation of VcArgument
}
private class VcBoolArgument: VcArgument {
#region Internal Instance Constructors
internal VcBoolArgument(ArgGroup group, string name): this(group, name, "true") {
}
internal VcBoolArgument(ArgGroup group, string name, string match): base(group, name) {
_match = match;
}
#endregion Internal Instance Constructors
#region Internal Instance Properties
///
/// Gets the string that the configuration setting should match in
/// order for the command line argument to be set.
///
public string Match {
get { return _match; }
}
#endregion Internal Instance Properties
#region Override implementation of VcArgument
internal override string MapValue(string propValue) {
if (string.Compare(propValue, Match, true, CultureInfo.InvariantCulture) == 0) {
return FormatOption(string.Empty);
}
return null;
}
#endregion Override implementation of VcArgument
#region Private Instance Methods
private string _match = "true";
#endregion Private Instance Methods
}
private class VcEnumArgument: VcArgument {
#region Internal Instance Constructors
internal VcEnumArgument(ArgGroup group, string name, string[] values): base(group, name) {
_values = values;
}
#endregion Internal Instance Constructors
#region Override implementation of VcArgument
internal override string MapValue(string propValue) {
int iValue = -1;
try {
iValue = Int32.Parse(propValue);
} catch(FormatException) {
return null;
}
if (iValue < 0 || iValue >= _values.Length || _values [iValue] == null) {
return null;
}
return FormatOption(_values [iValue]);
}
#endregion Override implementation of VcArgument
#region Private Instance Methods
private string[] _values;
#endregion Private Instance Methods
}
///
/// Allow us to assign an argument to a specific group.
///
[Flags]
public enum ArgGroup {
///
/// The argument is not assigned to any group.
///
Unassigned = 0,
///
/// The argument is ignored when the optimization level is set to
/// Minimum Size (1) or Maximum Size (2).
///
OptiIgnoreGroup = 1
}
}
}
nant-0.92-rc1/src/NAnt.VSNet/VcFileConfiguration.cs 0000644 0001750 0001750 00000024026 11757302274 021711 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2005 Gert Driesen
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Types;
namespace NAnt.VSNet {
///
/// Represents the configuration of a file.
///
public class VcFileConfiguration : VcConfigurationBase {
#region Internal Instance Constructors
internal VcFileConfiguration(string relativePath, string parentName, XmlElement elem, VcProjectConfiguration parentConfig, DirectoryInfo outputDir) : base(elem, parentConfig.Project, outputDir) {
if (relativePath == null) {
throw new ArgumentNullException("relativePath");
}
if (parentName == null) {
throw new ArgumentNullException("parentName");
}
if (parentConfig == null) {
throw new ArgumentNullException("parentConfig");
}
_relativePath = relativePath;
_parentName = parentName;
string excludeFromBuild = elem.GetAttribute("ExcludedFromBuild");
if (excludeFromBuild.Length != 0) {
_excludeFromBuild = string.Compare(excludeFromBuild.Trim(), "true", true, CultureInfo.InvariantCulture) == 0;
}
_parentConfig = parentConfig;
}
internal VcFileConfiguration(string relativePath, string parentName, VcProjectConfiguration parentConfig, DirectoryInfo outputDir) : base(parentConfig.Name, parentConfig.Project, outputDir) {
if (relativePath == null) {
throw new ArgumentNullException("relativePath");
}
if (parentName == null) {
throw new ArgumentNullException("parentName");
}
if (parentConfig == null) {
throw new ArgumentNullException("parentConfig");
}
_relativePath = relativePath;
_parentName = parentName;
_parentConfig = parentConfig;
}
#endregion Internal Instance Constructors
#region Public Instance Properties
///
/// Gets a value indication whether the file should be excluded from
/// the build for this configuration.
///
///
/// if the file should be excluded from the
/// build for this configuration; otherwise, .
///
public bool ExcludeFromBuild {
get { return _excludeFromBuild; }
}
///
/// Gets the relative path of the file.
///
///
/// The path of the file relative to the project directory.
///
public string RelativePath {
get { return _relativePath; }
}
#endregion Public Instance Properties
#region Override implementation of ConfigurationBase
///
/// Get the path of the output directory relative to the project
/// directory.
///
public override string RelativeOutputDir {
get { return ExpandMacros(_parentConfig.RawRelativeOutputDir) ; }
}
///
/// Expands the given macro.
///
/// The macro to expand.
///
/// The expanded macro.
///
///
/// The macro is not supported.
/// -or-
/// The macro is not implemented.
/// -or-
/// The macro cannot be expanded.
///
protected internal override string ExpandMacro(string macro) {
// perform case-insensitive expansion of macros
switch (macro.ToLower(CultureInfo.InvariantCulture)) {
case "inputdir":
return Path.GetDirectoryName(FileUtils.CombinePaths(Project.ProjectDirectory.FullName,
_relativePath)) + Path.DirectorySeparatorChar;
case "inputname":
return Path.GetFileNameWithoutExtension(_relativePath);
case "inputpath":
return FileUtils.CombinePaths(Project.ProjectDirectory.FullName, _relativePath);
case "inputfilename":
return Path.GetFileName(_relativePath);
case "inputext":
return Path.GetExtension(_relativePath);
case "safeparentname":
return _parentName.Replace(" ", string.Empty);
case "safeinputname":
return Path.GetFileNameWithoutExtension(_relativePath);
default:
return _parentConfig.ExpandMacro(macro);
}
}
#endregion Override implementation of ConfigurationBase
#region Override implementation of VcConfigurationBase
///
/// Gets the intermediate directory, specified relative to project
/// directory.
///
///
/// The intermediate directory, specified relative to project directory.
///
public override string IntermediateDir {
get { return ExpandMacros(_parentConfig.RawIntermediateDir); }
}
///
/// Gets the path for the output file.
///
///
/// The path for the output file, or if there's
/// no output file for this configuration.
///
public override string OutputPath {
get { return _parentConfig.OutputPath; }
}
///
/// Gets a comma-separated list of directories to scan for assembly
/// references.
///
///
/// A comma-separated list of directories to scan for assembly
/// references, or if no additional directories
/// should scanned.
///
public override string ReferencesPath {
get { return ExpandMacros(_parentConfig.RawReferencesPath); }
}
///
/// Gets the value of a given setting for a specified tool.
///
/// The name of the tool.
/// The name of the setting.
/// The value to return if setting is not defined in both the file and project configuration.
///
/// The value of a setting for the specified tool, or
/// if the setting is not defined in
/// both the file and project configuration.
///
///
///
/// If the setting is not defined in the file configuration, then
/// the project level setting will be used.
///
///
/// An empty setting value, which is used as a means to override the
/// project default, will be returned as a empty .
///
///
public override string GetToolSetting(string toolName, string settingName, string projectDefault) {
string setting = null;
Hashtable toolSettings = (Hashtable) Tools[toolName];
if (toolSettings != null) {
setting = (string) toolSettings[settingName];
if (setting != null) {
// expand macros
return ExpandMacros(setting);
}
}
setting = _parentConfig.GetToolSetting(toolName, settingName,
projectDefault, new ExpansionHandler(ExpandMacros));
return setting;
}
public override Hashtable GetToolArguments(string toolName, VcArgumentMap argMap, VcArgumentMap.ArgGroup ignoreGroup) {
ExpansionHandler expander = new ExpansionHandler(ExpandMacros);
Hashtable args;
if (_parentConfig != null) {
args = _parentConfig.GetToolArguments(toolName, argMap, ignoreGroup, expander);
} else {
args = CollectionsUtil.CreateCaseInsensitiveHashtable();
}
Hashtable toolSettings = (Hashtable) Tools[toolName];
if (toolSettings != null) {
foreach (DictionaryEntry de in toolSettings) {
string arg = argMap.GetArgument((string) de.Key, ExpandMacros((string) de.Value), ignoreGroup);
if (arg != null) {
args[(string) de.Key] = arg;
}
}
}
return args;
}
#endregion Override implementation of VcConfigurationBase
#region Private Instance Fields
private readonly string _relativePath;
private readonly string _parentName;
private readonly bool _excludeFromBuild;
private readonly VcProjectConfiguration _parentConfig;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/ConfigurationBase.cs 0000644 0001750 0001750 00000021306 11757302274 021411 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
public abstract class ConfigurationBase {
#region Protected Instance Constructors
///
/// Initializes a new instance of the
/// class with the given .
///
/// The project of the configuration.
protected ConfigurationBase(ProjectBase project) {
if (project == null) {
throw new ArgumentNullException("project");
}
_project = project;
_extraOutputFiles = CollectionsUtil.CreateCaseInsensitiveHashtable();
}
#endregion Protected Instance Constructors
#region Public Instance Properties
///
/// Gets the project.
///
public ProjectBase Project {
get { return _project;}
}
///
/// Gets the name of the configuration.
///
public abstract string Name {
get;
}
///
/// Get the directory in which intermediate build output will be stored
/// for this configuration.
///
///
///
/// This is a directory relative to the project directory named
/// obj\<configuration name>.
///
///
/// .resx and .licx files will only be recompiled if the
/// compiled resource files in the are not
/// uptodate.
///
///
public virtual DirectoryInfo ObjectDir {
get {
return new DirectoryInfo(FileUtils.CombinePaths(Project.ObjectDir.FullName,
Name));
}
}
///
/// Gets the output directory.
///
public abstract DirectoryInfo OutputDir {
get;
}
///
/// Gets the path for the output file.
///
public abstract string OutputPath {
get;
}
///
/// Gets the path in which the output file will be created before its
/// copied to the actual output path.
///
public abstract string BuildPath {
get;
}
///
/// Get the path of the output directory relative to the project
/// directory.
///
public abstract string RelativeOutputDir {
get;
}
///
/// Gets the platform that the configuration targets.
///
///
/// The platform targeted by the configuration.
///
public abstract string PlatformName {
get;
}
///
/// Gets the set of output files that is specific to the project
/// configuration.
///
///
/// The set of output files that is specific to the project
/// configuration.
///
///
/// The key of the case-insensitive is the
/// full path of the output file and the value is the path relative to
/// the output directory.
///
public Hashtable ExtraOutputFiles {
get { return _extraOutputFiles; }
}
#endregion Public Instance Properties
#region Protected Instance Properties
protected SolutionTask SolutionTask {
get { return Project.SolutionTask; }
}
#endregion Protected Instance Properties
#region Public Instance Methods
public string ExpandMacros(string s) {
if (s == null) {
return s;
}
return _rxMacro.Replace(s, new MatchEvaluator(EvaluateMacro));
}
#endregion Public Instance Methods
#region Protected Instance Methods
///
/// Expands the given macro.
///
/// The macro to expand.
///
/// The expanded macro.
///
///
/// The macro is not supported.
/// -or-
/// The macro is not implemented.
/// -or-
/// The macro cannot be expanded.
///
///
/// Expansion of a given macro is not yet implemented.
///
protected internal virtual string ExpandMacro(string macro) {
// perform case-insensitive expansion of macros
switch (macro.ToLower(CultureInfo.InvariantCulture)) {
case "outdir": // E.g. bin\Debug\
return RelativeOutputDir;
case "configurationname": // E.g. Debug
return Name;
case "targetname": // E.g. WindowsApplication1
return Path.GetFileNameWithoutExtension(Path.GetFileName(
OutputPath));
case "targetpath": // E.g. C:\Doc...\Visual Studio Projects\WindowsApplications1\bin\Debug\WindowsApplications1.exe
return OutputPath;
case "targetext": // E.g. .exe
return Path.GetExtension(OutputPath);
case "targetfilename": // E.g. WindowsApplications1.exe
return Path.GetFileName(OutputPath);
case "targetdir": // Absolute path to OutDir
return OutputDir.FullName + (OutputDir.FullName.EndsWith(
Path.DirectorySeparatorChar.ToString(CultureInfo.InvariantCulture))
? string.Empty : Path.DirectorySeparatorChar.ToString(CultureInfo.InvariantCulture));
case "platformname": // .NET, does this value ever change?
return PlatformName;
}
// expand using solution level macro's
string expandedMacro = Project.SolutionTask.ExpandMacro(macro);
if (expandedMacro != null) {
return expandedMacro;
}
// expand using project level macro's
expandedMacro = Project.ExpandMacro(macro);
if (expandedMacro != null) {
return expandedMacro;
}
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Macro \"{0}\" is not supported.", macro), Location.UnknownLocation);
}
#endregion Protected Instance Methods
#region Private Instance Methods
///
/// Is called each time a regular expression match is found during a
/// operation.
///
/// The resulting from a single regular expression match during a .
///
/// The expanded .
///
private string EvaluateMacro(Match m) {
return ExpandMacro(m.Groups[1].Value);
}
#endregion Private Instance Methods
#region Private Instance Fields
private readonly ProjectBase _project;
private readonly Regex _rxMacro = new Regex(@"\$\((\w+)\)");
private Hashtable _extraOutputFiles;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/ManagedAssemblyReference.cs 0000644 0001750 0001750 00000033513 11757302274 022665 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Xml;
using Microsoft.Win32;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
public class ManagedAssemblyReference : AssemblyReferenceBase {
public ManagedAssemblyReference(XmlElement xmlDefinition, ReferencesResolver referencesResolver, ProjectBase parent, GacCache gacCache) : base(xmlDefinition, referencesResolver, parent, gacCache) {
XmlAttribute privateAttribute = xmlDefinition.Attributes["Private"];
if (privateAttribute != null) {
_isPrivateSpecified = true;
_isPrivate = bool.Parse(privateAttribute.Value);
}
// determine name of reference
XmlAttribute assemblyNameAttribute = XmlDefinition.Attributes["AssemblyName"];
if (assemblyNameAttribute != null) {
_name = assemblyNameAttribute.Value;
}
_assemblyFile = ResolveAssemblyReference();
}
#region Override implementation of AssemblyReferenceBase
protected override bool IsPrivate {
get { return _isPrivate; }
}
protected override bool IsPrivateSpecified {
get { return _isPrivateSpecified; }
}
///
/// Resolves an assembly reference.
///
///
/// The full path to the resolved assembly, or
/// if the assembly reference could not be resolved.
///
///
///
/// Visual Studio .NET uses the following search mechanism :
///
///
///
///
/// The project directory.
///
///
///
///
/// The directories specified in the "ReferencePath" property,
/// which is stored in the .USER file.
///
///
///
///
/// The .NET Framework directory (see KB306149)
///
///
///
///
///
/// The directories specified under the following registry
/// keys:
///
///
///
///
/// HKLM\SOFTWARE\Microsoft\.NETFramework\AssemblyFolders
///
///
///
///
/// HKCU\SOFTWARE\Microsoft\.NETFramework\AssemblyFolders
///
///
///
///
/// HKLM\SOFTWARE\Microsoft\VisualStudio\<major version>.<minor version>\AssemblyFolders
///
///
///
///
/// HKCU\SOFTWARE\Microsoft\VisualStudio\<major version>.<minor version>\AssemblyFolders
///
///
///
///
/// Future versions of Visual Studio .NET will also check
/// in:
///
///
///
///
/// HKLM\SOFTWARE\Microsoft\.NETFramework\AssemblyFoldersEx
///
///
///
///
/// HKCU\SOFTWARE\Microsoft\.NETFramework\AssemblyFoldersEx
///
///
///
///
///
///
///
/// The HintPath.
///
///
///
///
protected override string ResolveAssemblyReference() {
// check if assembly reference was resolved before
if (_assemblyFile != null) {
// if assembly file actually exists, there's no need to resolve
// the assembly reference again
if (File.Exists(_assemblyFile)) {
return _assemblyFile;
}
}
XmlElement referenceElement = XmlDefinition;
string assemblyFileName = Name + ".dll";
// 1. The project directory
// NOT SURE IF THIS IS CORRECT
// 2. The ReferencePath
// NOT SURE WE SHOULD DO THIS ONE
// 3. The .NET Framework directory
string resolvedAssemblyFile = ResolveFromFramework(assemblyFileName);
if (resolvedAssemblyFile != null) {
return resolvedAssemblyFile;
}
// 4. AssemblyFolders
resolvedAssemblyFile = ResolveFromAssemblyFolders(referenceElement,
assemblyFileName);
if (resolvedAssemblyFile != null) {
return resolvedAssemblyFile;
}
// ResolveFromRelativePath will return a path regardless of
// whether the file actually exists
//
// the file might actually be created as result of building
// a project
resolvedAssemblyFile = ResolveFromRelativePath(
referenceElement.GetAttribute("HintPath"));
if (resolvedAssemblyFile != null) {
return resolvedAssemblyFile;
}
// assembly reference could not be resolved
return null;
}
#endregion Override implementation of AssemblyReferenceBase
#region Override implementation of ReferenceBase
///
/// Gets the name of the referenced assembly.
///
///
/// The name of the referenced assembly, or if
/// the name could not be determined.
///
public override string Name {
get { return _name; }
}
#endregion Override implementation of ReferenceBase
#region Private Instance Properties
///
/// Gets the Visual Studio .NET AssemblyFolders registry key matching
/// the current target framework.
///
///
/// The Visual Studio .NET AssemblyFolders registry key matching the
/// current target framework.
///
/// The current target framework is not supported.
///
/// We use the target framework instead of the product version of the
/// containing project file to determine what registry key to scan, as
/// we don't want to use assemblies meant for uplevel framework versions.
///
private string AssemblyFoldersKey {
get {
string visualStudioVersion = Parent.SolutionTask.Project.
TargetFramework.VisualStudioVersion.ToString();
return string.Format(CultureInfo.InvariantCulture,
@"SOFTWARE\Microsoft\VisualStudio\{0}\AssemblyFolders",
visualStudioVersion);
}
}
#endregion Private Instance Properties
#region Private Instance Methods
private string GetComponentAssemblyFolder(XmlElement referenceElement) {
string componentAssemblyFolder = null;
if (referenceElement.Attributes["AssemblyFolderKey"] != null) {
string assemblyFolderKey = referenceElement.Attributes["AssemblyFolderKey"].Value;
RegistryKey registryHive = null;
string[] assemblyFolderKeyParts = assemblyFolderKey.Split('\\');
if (assemblyFolderKeyParts.Length < 2 || assemblyFolderKeyParts.Length > 3) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Invalid AssemblyFolderKey \"{0}\" for assembly"
+ " reference \"{1}\", referenced by project"
+ " \"{2}\".", assemblyFolderKey, Name, Parent.Name),
Location.UnknownLocation);
}
switch (assemblyFolderKeyParts[0]) {
case "hklm":
registryHive = Registry.LocalMachine;
break;
case "hkcu":
registryHive = Registry.CurrentUser;
break;
default:
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Invalid AssemblyFolderKey \"{0}\" for assembly"
+ " reference \"{1}\", referenced by project"
+ " \"{2}\".", assemblyFolderKey, Name, Parent.Name),
Location.UnknownLocation);
}
RegistryKey repositoryKey = null;
// if AssemblyFolderKey has three parts, then the second
// parts specifies the registry key to search
if (assemblyFolderKeyParts.Length == 3) {
switch (assemblyFolderKeyParts[1]) {
case "dn":
repositoryKey = registryHive.OpenSubKey(@"SOFTWARE\Microsoft\.NETFramework\AssemblyFolders");
break;
default:
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Invalid AssemblyFolderKey \"{0}\" for assembly"
+ " reference \"{1}\", referenced by project"
+ " \"{2}\".", assemblyFolderKey, Name, Parent.Name),
Location.UnknownLocation);
}
} else {
repositoryKey = registryHive.OpenSubKey(AssemblyFoldersKey);
}
if (repositoryKey != null) {
RegistryKey componentKey = repositoryKey.OpenSubKey(
assemblyFolderKeyParts[assemblyFolderKeyParts.Length - 1]);
if (componentKey != null) {
string folder = componentKey.GetValue(string.Empty) as string;
if (folder != null) {
componentAssemblyFolder = folder;
} else {
Log(Level.Debug, "Default value for AssemblyFolder"
+ " \"{0}\" does not exist or is not a string"
+ " value.", assemblyFolderKey);
}
} else {
Log(Level.Debug, "Component key for AssemblyFolder \"{0}\""
+ " does not exist.", assemblyFolderKey);
}
} else {
Log(Level.Debug, "Repository for AssemblyFolder \"{0}\" does"
+ " not exist.", assemblyFolderKey);
}
}
return componentAssemblyFolder;
}
protected override string ResolveFromAssemblyFolders(XmlElement referenceElement, string fileName) {
string resolvedAssemblyFile = null;
string componentAssemblyFolder = GetComponentAssemblyFolder(
referenceElement);
if (componentAssemblyFolder != null) {
StringCollection folderList = new StringCollection();
folderList.Add(componentAssemblyFolder);
resolvedAssemblyFile = ResolveFromFolderList(folderList,
fileName);
}
if (resolvedAssemblyFile == null) {
resolvedAssemblyFile = base.ResolveFromAssemblyFolders(
referenceElement, fileName);
}
return resolvedAssemblyFile;
}
#endregion Private Instance Methods
#region Private Instance Fields
private readonly string _assemblyFile;
private readonly bool _isPrivateSpecified;
private readonly bool _isPrivate;
private readonly string _name = string.Empty;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/JSharpProject.cs 0000644 0001750 0001750 00000022171 11757302274 020526 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Laurent Arnal (laurent@clae.net)
using System;
using System.CodeDom.Compiler;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
public class JSharpProject : ManagedProjectBase {
#region Public Instance Constructors
public JSharpProject(SolutionBase solution, string projectPath, XmlElement xmlDefinition, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver, DirectoryInfo outputDir) : base(solution, projectPath, xmlDefinition, solutionTask, tfc, gacCache, refResolver, outputDir) {
}
#endregion Public Instance Constructors
#region Override implementation of ProjectBase
///
/// Gets the type of the project.
///
///
/// The type of the project.
///
public override ProjectType Type {
get { return ProjectType.JSharp; }
}
///
/// Verifies whether the specified XML fragment represents a valid project
/// that is supported by this .
///
/// XML fragment representing the project file.
///
/// The XML fragment is not supported by this .
/// -or-
/// The XML fragment does not represent a valid project (for this ).
///
protected override void VerifyProjectXml(XmlElement docElement) {
if (!IsSupported(docElement)) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Project '{0}' is not a valid J# project.", ProjectPath),
Location.UnknownLocation);
}
}
///
/// Returns the Visual Studio product version of the specified project
/// XML fragment.
///
/// The document element of the project.
///
/// The Visual Studio product version of the specified project XML
/// fragment.
///
///
/// The product version could not be determined.
/// -or-
/// The product version is not supported.
///
protected override ProductVersion DetermineProductVersion(XmlElement docElement) {
return GetProductVersion(docElement.SelectSingleNode("./VISUALJSHARP"));
}
///
/// Prepares the project for being built.
///
/// The solution configuration that is built.
///
/// Ensures the configuration-level object directory exists and ensures
/// that none of the output files are marked read-only.
///
protected override void Prepare(Configuration solutionConfiguration) {
// Visual J#.NET uses the \obj\
// as working directory, so we should do the same to make
// sure relative paths are resolved correctly
// (eg. AssemblyKeyFile attribute)
// obtain project configuration (corresponding with solution configuration)
ConfigurationBase config = BuildConfigurations[solutionConfiguration];
// ensure configuration-level object directory exists
if (!config.ObjectDir.Exists) {
config.ObjectDir.Create();
config.ObjectDir.Refresh();
}
}
///
/// Returns a for launching the compiler
/// for this project.
///
/// The configuration to build.
/// The response file for the compiler.
///
/// A for launching the compiler for
/// this project.
///
protected override ProcessStartInfo GetProcessStartInfo(ConfigurationBase config, string responseFile) {
ProcessStartInfo psi = new ProcessStartInfo(FileUtils.CombinePaths(SolutionTask.
Project.TargetFramework.FrameworkDirectory.FullName, "vjc.exe"),
"@\"" + responseFile + "\"");
// to resolve the path to the file specified in the AssemblyKeyFile
// attribute, the command line compilers try to resolve that relative
// path using the output directory and the current directory
//
// VS.NET compiles assembly to the intermediate output directory and
// uses the solution directory as current directory
if (SolutionTask.SolutionFile != null) {
psi.WorkingDirectory = Path.GetDirectoryName(SolutionTask.SolutionFile.FullName);
} else {
psi.WorkingDirectory = ProjectDirectory.FullName;
}
return psi;
}
#endregion Override implementation of ProjectBase
#region Override implementation of ManagedProjectBase
///
/// Gets the default file extension of sources for this project.
///
///
/// For J# projects, the default file extension is ".jsl".
///
protected override string FileExtension {
get { return ".jsl"; }
}
///
/// Returns the project location from the specified project XML fragment.
///
/// XML fragment representing the project file.
///
/// The project location of the specified project XML file.
///
///
/// The project location could not be determined.
/// -or-
/// The project location is invalid.
///
protected override ProjectLocation DetermineProjectLocation(XmlElement docElement) {
return GetProjectLocation(docElement.SelectSingleNode("./VISUALJSHARP"));
}
#endregion Override implementation of ManagedProjectBase
#region Public Static Methods
///
/// Returns a value indicating whether the project represented by the
/// specified XML fragment is supported by .
///
/// XML fragment representing the project to check.
///
/// if supports
/// the specified project; otherwise, .
///
///
///
/// A project is identified as as J# project, if the XML fragment at
/// least has the following information:
///
///
///
///
/// ...
///
///
/// ]]>
///
///
public static bool IsSupported(XmlElement docElement) {
if (docElement == null) {
return false;
}
if (docElement.Name != "VisualStudioProject") {
return false;
}
XmlNode projectNode = docElement.SelectSingleNode("./VISUALJSHARP");
if (projectNode == null) {
return false;
}
try {
GetProductVersion(projectNode);
// no need to perform version check here as this is done in
// GetProductVersion
} catch {
// product version could not be determined or is not supported
return false;
}
return true;
}
#endregion Public Static Methods
}
}
nant-0.92-rc1/src/NAnt.VSNet/ManagedProjectBase.cs 0000644 0001750 0001750 00000167251 11757302274 021477 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Text;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.DotNet.Tasks;
using NAnt.DotNet.Types;
using NAnt.Win32.Tasks;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
public abstract class ManagedProjectBase : ProjectBase {
#region Public Instance Constructors
protected ManagedProjectBase(SolutionBase solution, string projectPath, XmlElement xmlDefinition, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver, DirectoryInfo outputDir) : base(xmlDefinition, solutionTask, tfc, gacCache, refResolver, outputDir) {
if (projectPath == null) {
throw new ArgumentNullException("projectPath");
}
if (xmlDefinition == null) {
throw new ArgumentNullException("xmlDefinition");
}
_references = new ArrayList();
_neutralResources = new ArrayList();
_localizedResources = new ArrayList();
_sourceFiles = CollectionsUtil.CreateCaseInsensitiveHashtable();
_projectPath = projectPath;
_projectLocation = DetermineProjectLocation(xmlDefinition);
if (!IsWebProject) {
_projectDirectory = new FileInfo(projectPath).Directory;
} else {
string projectDirectory = projectPath.Replace(":", "_");
projectDirectory = projectDirectory.Replace("/", "_");
projectDirectory = projectDirectory.Replace("\\", "_");
_projectDirectory = new DirectoryInfo(FileUtils.CombinePaths(
TemporaryFiles.BasePath, projectDirectory));
// ensure project directory exists
if (!_projectDirectory.Exists) {
_projectDirectory.Create();
_projectDirectory.Refresh();
}
_webProjectBaseUrl = projectPath.Substring(0, projectPath.LastIndexOf("/"));
}
_projectSettings = new ProjectSettings(xmlDefinition, (XmlElement)
xmlDefinition.SelectSingleNode("//Build/Settings"), this);
XmlNodeList nlConfigurations = xmlDefinition.SelectNodes("//Config");
foreach (XmlElement elemConfig in nlConfigurations) {
ConfigurationSettings cs = new ConfigurationSettings(this, elemConfig, OutputDir);
ProjectConfigurations[Configuration.Parse(cs.Name)] = cs;
}
XmlNodeList nlReferences = xmlDefinition.SelectNodes("//References/Reference");
foreach (XmlElement elemReference in nlReferences) {
ReferenceBase reference = CreateReference(solution, elemReference);
_references.Add(reference);
}
XmlNodeList nlFiles = xmlDefinition.SelectNodes("//Files/Include/File");
foreach (XmlElement elemFile in nlFiles) {
string buildAction = StringUtils.ConvertEmptyToNull(elemFile.GetAttribute("BuildAction"));
string sourceFile;
if (!String.IsNullOrEmpty(elemFile.GetAttribute("Link"))) {
sourceFile = FileUtils.GetFullPath(FileUtils.CombinePaths(
ProjectDirectory.FullName, elemFile.GetAttribute("Link")));
} else {
sourceFile = FileUtils.GetFullPath(FileUtils.CombinePaths(
ProjectDirectory.FullName, elemFile.GetAttribute("RelPath")));
}
if (IsWebProject) {
WebDavClient wdc = new WebDavClient(new Uri(_webProjectBaseUrl));
wdc.DownloadFile(sourceFile, elemFile.Attributes["RelPath"].Value);
switch (buildAction) {
case "Compile":
_sourceFiles[sourceFile] = null;
break;
case "EmbeddedResource":
RegisterEmbeddedResource(sourceFile, elemFile);
break;
case null:
if (string.Compare(Path.GetExtension(sourceFile), FileExtension, true, CultureInfo.InvariantCulture) == 0) {
_sourceFiles[sourceFile] = null;
}
break;
}
} else {
switch (buildAction) {
case "Compile":
_sourceFiles[sourceFile] = null;
break;
case "EmbeddedResource":
RegisterEmbeddedResource(sourceFile, elemFile);
break;
case null:
if (string.Compare(Path.GetExtension(sourceFile), FileExtension, true, CultureInfo.InvariantCulture) == 0) {
_sourceFiles[sourceFile] = null;
}
break;
}
// check if file is "App.config" (using case-insensitive comparison)
if (string.Compare("App.config", elemFile.GetAttribute("RelPath"), true, CultureInfo.InvariantCulture) == 0) {
// App.config is only an output file for executable projects
if (ProjectSettings.OutputType == ManagedOutputType.Executable || ProjectSettings.OutputType == ManagedOutputType.WindowsExecutable) {
ExtraOutputFiles[sourceFile] = ProjectSettings.OutputFileName
+ ".config";
}
}
}
}
}
#endregion Public Instance Constructors
#region Public Instance Properties
public ProjectSettings ProjectSettings {
get { return _projectSettings; }
}
#endregion Public Instance Properties
#region Protected Instance Properties
///
/// Gets the default file extension of sources for this project.
///
///
/// The default file extension of sources for this project.
///
protected abstract string FileExtension {
get;
}
#endregion Protected Instance Properties
#region Private Instance Properties
///
/// Gets a value indicating if this is a web project.
///
///
/// if this is a web project; otherwise,
/// .
///
///
/// If the url of a web project has been mapped to a local path
/// (using the <webmap> element), then this property will return
/// for a
/// project.
///
private bool IsWebProject {
get { return ProjectFactory.IsUrl(_projectPath); }
}
#endregion Private Instance Properties
#region Override implementation of ProjectBase
///
/// Gets the name of the VS.NET project.
///
public override string Name {
get {
string projectPath;
if (ProjectFactory.IsUrl(_projectPath)) {
// construct uri for project path
Uri projectUri = new Uri(_projectPath);
// get last segment of the uri (which should be the
// project file itself)
projectPath = projectUri.LocalPath;
} else {
projectPath = ProjectPath;
}
// return file part without extension
return Path.GetFileNameWithoutExtension(projectPath);
}
}
///
/// Gets the path of the VS.NET project.
///
public override string ProjectPath {
get {
if (ProjectFactory.IsUrl(_projectPath)) {
return _projectPath;
} else {
return FileUtils.GetFullPath(_projectPath);
}
}
}
///
/// Gets the directory containing the VS.NET project.
///
public override DirectoryInfo ProjectDirectory {
get { return _projectDirectory; }
}
///
/// Get the location of the project.
///
public override ProjectLocation ProjectLocation {
get { return _projectLocation; }
}
///
/// Gets or sets the unique identifier of the VS.NET project.
///
public override string Guid {
get { return ProjectSettings.Guid; }
set { throw new InvalidOperationException( "It is not allowed to change the GUID of a C#/VB.NET project" ); }
}
public override ArrayList References {
get { return _references; }
}
///
/// Gets a value indicating whether building the project for the specified
/// build configuration results in managed output.
///
/// The solution configuration that is built.
///
/// .
///
public override bool IsManaged(Configuration solutionConfiguration) {
return true;
}
///
/// Prepares the project for being built.
///
/// The solution configuration that is built.
///
/// Ensures the configuration-level object directory exists and ensures
/// that none of the output files are marked read-only.
///
protected override void Prepare(Configuration solutionConfiguration) {
// obtain project configuration (corresponding with solution configuration)
ConfigurationBase config = BuildConfigurations[solutionConfiguration];
// ensure configuration-level object directory exists
if (!config.ObjectDir.Exists) {
config.ObjectDir.Create();
config.ObjectDir.Refresh();
}
// ensure that none of the output files in the configuration-level
// object directory are marked read-only
base.Prepare(solutionConfiguration);
}
///
/// Gets the complete set of output files for the project configuration
/// matching the specified solution configuration.
///
/// The solution configuration that is built.
/// The set of output files to be updated.
///
///
/// The key of the case-insensitive is the
/// full path of the output file and the value is the path relative to
/// the output directory.
///
///
/// If the project is not configured to be built for the specified
/// solution configuration, then no output files are added.
///
///
public override void GetOutputFiles(Configuration solutionConfiguration, Hashtable outputFiles) {
base.GetOutputFiles (solutionConfiguration, outputFiles);
// obtain project configuration (corresponding with solution configuration)
ConfigurationSettings projectConfig = (ConfigurationSettings)
BuildConfigurations[solutionConfiguration];
if (projectConfig == null) {
// the project is not configured to be built for the specified
// solution configuration
return;
}
// add type library
if (projectConfig.RegisterForComInterop) {
string typeLib = GetTypeLibraryPath(projectConfig);
if (!outputFiles.ContainsKey(typeLib)) {
outputFiles.Add(typeLib, Path.GetFileName(typeLib));
}
}
// add satellite assemblies
Hashtable resourceSets = GetLocalizedResources();
foreach (LocalizedResourceSet localizedResourceSet in resourceSets.Values) {
FileInfo satelliteAssembly = localizedResourceSet.GetSatelliteAssemblyPath(
projectConfig, ProjectSettings);
// skip files that do not exist, or are already in hashtable
if (satelliteAssembly.Exists && !outputFiles.ContainsKey(satelliteAssembly.FullName)) {
string relativePath = localizedResourceSet.GetRelativePath(
ProjectSettings);
outputFiles.Add(satelliteAssembly.FullName, relativePath);
}
}
}
protected override BuildResult Build(Configuration solutionConfiguration) {
bool bSuccess = true;
bool outputUpdated;
string tempFile = null;
GacCache.RecreateDomain();
try {
// obtain project configuration (corresponding with solution configuration)
ConfigurationSettings cs = (ConfigurationSettings) BuildConfigurations[solutionConfiguration];
// perform prebuild actions (for VS.NET 2003 and higher)
if (!PreBuild(cs)) {
// no longer bother trying to build the project and do not
// execute any post-build events
return BuildResult.Failed;
}
// unregister types exposed to COM, and unregister type
// library (if it exists)
UnregisterForComInterop(cs, solutionConfiguration);
// ensure temp directory exists
if (!Directory.Exists(TemporaryFiles.BasePath)) {
Directory.CreateDirectory(TemporaryFiles.BasePath);
}
// compile neutral and localized resx files
CompileResXFiles(solutionConfiguration);
// check if project output needs to be rebuilt
if (CheckUpToDate(solutionConfiguration)) {
Log(Level.Verbose, "Project is up-to-date.");
// project output is up-to-date
outputUpdated = false;
} else {
// prepare the project for build
Prepare(solutionConfiguration);
// check if project does not contain any sources
if (_sourceFiles.Count == 0) {
// create temp file
tempFile = Path.GetTempFileName();
// add temp file to collection of sources to compile
// as command line compilers require a least one source
// file to be specified, but VS.NET supports empty
// projects
_sourceFiles[tempFile] = null;
}
string tempResponseFile = FileUtils.CombinePaths(TemporaryFiles.BasePath,
CommandFile);
using (StreamWriter sw = File.CreateText(tempResponseFile)) {
// write compiler options
WriteCompilerOptions(sw, solutionConfiguration);
}
Log(Level.Verbose, "Starting compiler...");
if (SolutionTask.Verbose) {
using (StreamReader sr = new StreamReader(tempResponseFile)) {
Log(Level.Verbose, "Commands:");
// increment indentation level
SolutionTask.Project.Indent();
try {
while (true) {
// read line
string line = sr.ReadLine();
if (line == null) {
break;
}
// display line
Log(Level.Verbose, " " + line);
}
} finally {
// restore indentation level
SolutionTask.Project.Unindent();
}
}
}
ProcessStartInfo psi = GetProcessStartInfo(cs, tempResponseFile);
psi.UseShellExecute = false;
psi.RedirectStandardOutput = true;
// start compiler
Process p = Process.Start(psi);
while (true) {
// read line
string line = p.StandardOutput.ReadLine();
if (line == null) {
break;
}
// display line
Log(Level.Info, line);
}
p.WaitForExit();
int exitCode = p.ExitCode;
Log(Level.Verbose, "{0}! (exit code = {1})", (exitCode == 0) ? "Success" : "Failure", exitCode);
if (exitCode > 0) {
bSuccess = false;
}
// project output has been updated
outputUpdated = true;
}
#region Process culture-specific resource files
Log(Level.Verbose, "Building satellite assemblies...");
Hashtable resourceSets = GetLocalizedResources();
foreach (LocalizedResourceSet localizedResourceSet in resourceSets.Values) {
AssemblyLinkerTask al = new AssemblyLinkerTask();
al.Project = SolutionTask.Project;
al.NamespaceManager = SolutionTask.NamespaceManager;
al.Parent = SolutionTask;
al.BaseDirectory = cs.OutputDir;
al.InitializeTaskConfiguration();
DirectoryInfo satelliteBuildDir = localizedResourceSet.
GetBuildDirectory(cs);
// ensure satellite build directory exists
if (!satelliteBuildDir.Exists) {
satelliteBuildDir.Create();
}
al.OutputFile = localizedResourceSet.GetSatelliteAssemblyPath(
cs, ProjectSettings);
al.OutputTarget = "lib";
al.Culture = localizedResourceSet.Culture.Name;
al.TemplateFile = new FileInfo(cs.BuildPath);
foreach (Resource resource in localizedResourceSet.Resources) {
FileInfo compiledResourceFile = null;
if (resource.IsResX) {
// localized resx files have already been compiled
compiledResourceFile = resource.GetCompiledResourceFile(
solutionConfiguration);
} else {
// compile resource
compiledResourceFile = resource.Compile(solutionConfiguration);
}
// add resources to embed
EmbeddedResource embeddedResource = new EmbeddedResource(
compiledResourceFile.FullName, resource.GetManifestResourceName(solutionConfiguration));
al.EmbeddedResources.Add(embeddedResource);
}
// increment indentation level
SolutionTask.Project.Indent();
try {
Log(Level.Verbose, " - {0}", al.Culture);
// run assembly linker
al.Execute();
} finally {
// restore indentation level
SolutionTask.Project.Unindent();
}
}
#endregion Process culture-specific resource files
#region Register project output for COM Interop
// check if we need to build type library
if (cs.RegisterForComInterop) {
// create type library in output dir, and register it using
// that path to match VS.NET
string typeLibPath = GetTypeLibraryPath(cs);
RegisterForComInterop(cs, solutionConfiguration, typeLibPath);
// copy generated type library to object directory to match
// VS.NET
string objTypeLibPath = Path.ChangeExtension(cs.BuildPath, ".tlb");
CopyFile(new FileInfo(typeLibPath), new FileInfo (objTypeLibPath),
SolutionTask);
}
#endregion Register project output for COM Interop
#region Deploy project and configuration level output files
// copy primary project output (and related files)
Hashtable outputFiles = CollectionsUtil.CreateCaseInsensitiveHashtable();
GetOutputFiles(solutionConfiguration, outputFiles);
foreach (DictionaryEntry de in outputFiles) {
string srcPath = (string) de.Key;
string relativePath = (string) de.Value;
if (IsWebProject) {
WebDavClient wdc = new WebDavClient(new Uri(_webProjectBaseUrl));
wdc.UploadFile(srcPath, FileUtils.CombinePaths(cs.RelativeOutputDir,
relativePath).Replace(@"\", "/"));
} else {
// determine destination file
FileInfo destFile = new FileInfo(FileUtils.CombinePaths(cs.OutputDir.FullName,
relativePath));
// copy file using task
CopyFile(new FileInfo(srcPath), destFile, SolutionTask);
}
}
#endregion Deploy project and configuration level output files
if (ProjectSettings.RunPostBuildEvent != null) {
if (!PostBuild(cs, !outputUpdated || bSuccess, outputUpdated)) {
bSuccess = false;
}
}
if (!bSuccess) {
Log(Level.Error, "Build failed.");
return BuildResult.Failed;
}
return outputUpdated ? BuildResult.SuccessOutputUpdated : BuildResult.Success;
} finally {
// check if temporary file was created to support empty projects
if (tempFile != null) {
// ensure temp file is deleted
File.Delete(tempFile);
}
}
}
#endregion Override implementation of ProjectBase
#region Protected Instance Methods
///
/// Returns a for launching the compiler
/// for this project.
///
/// The configuration to build.
/// The response file for the compiler.
///
/// A for launching the compiler for
/// this project.
///
protected abstract ProcessStartInfo GetProcessStartInfo(ConfigurationBase config, string responseFile);
protected virtual ReferenceBase CreateReference(SolutionBase solution, XmlElement xmlDefinition) {
if (solution == null) {
throw new ArgumentNullException("solution");
}
if (xmlDefinition == null) {
throw new ArgumentNullException("xmlDefinition");
}
if (xmlDefinition.Attributes["Project"] != null) {
return new ManagedProjectReference(xmlDefinition, ReferencesResolver, this,
solution, ProjectSettings.TemporaryFiles, GacCache, OutputDir);
} else if (xmlDefinition.Attributes["WrapperTool"] != null) {
// wrapper
return new ManagedWrapperReference(xmlDefinition, ReferencesResolver,
this, GacCache, ProjectSettings);
} else {
// assembly reference
return new ManagedAssemblyReference(xmlDefinition, ReferencesResolver,
this, GacCache);
}
}
public override ProjectReferenceBase CreateProjectReference(ProjectBase project, bool isPrivateSpecified, bool isPrivate) {
return new ManagedProjectReference(project, this, isPrivateSpecified,
isPrivate);
}
protected virtual void WriteCompilerOptions(StreamWriter sw, Configuration solutionConfiguration) {
// obtain project configuration (corresponding with solution configuration)
ConfigurationSettings config = (ConfigurationSettings) BuildConfigurations[solutionConfiguration];
// write project level options (eg. /target)
foreach (string setting in ProjectSettings.Settings) {
sw.WriteLine(setting);
}
// write configuration-level compiler options
foreach (string setting in config.Settings) {
sw.WriteLine(setting);
}
// write assembly references to response file
foreach (string assemblyReference in GetAssemblyReferences(solutionConfiguration)) {
sw.WriteLine("/r:\"{0}\"", assemblyReference);
}
if (ProjectSettings.ApplicationIcon != null) {
sw.WriteLine(@"/win32icon:""{0}""",
ProjectSettings.ApplicationIcon.FullName);
}
if (_neutralResources.Count > 0) {
WriteNeutralResourceOptions(sw, solutionConfiguration);
}
// before writing files to response file, allow project specific
// options to be written (eg. VB specific options)
WriteProjectOptions(sw);
// add the files to compile
foreach (string file in _sourceFiles.Keys) {
sw.WriteLine(@"""" + file + @"""");
}
}
protected virtual void WriteProjectOptions(StreamWriter sw) {
}
///
/// Returns the project location from the specified project XML fragment.
///
/// XML fragment representing the project file.
///
/// The project location of the specified project XML file.
///
///
/// The project location could not be determined.
/// -or-
/// The project location is invalid.
///
protected abstract ProjectLocation DetermineProjectLocation(XmlElement docElement);
#endregion Protected Instance Methods
#region Private Instance Methods
///
/// Gets the absolute path of the type library for the project
/// output.
///
/// The configuration to build.
///
/// The absolute path of the type library for the project output.
///
private string GetTypeLibraryPath(ConfigurationSettings config) {
if (config == null) {
throw new ArgumentNullException("config");
}
return Path.ChangeExtension(config.OutputPath, ".tlb");
}
///
/// Generates a type library for the specified assembly, registers it.
///
/// The project configuration that is built.
/// The solution configuration that is built.
/// The path of the type library to generate.
///
/// The regasm tool is used to generate the type library.
///
private void RegisterForComInterop(ConfigurationSettings config, Configuration solutionConfiguration, string typelibPath) {
Log(Level.Verbose, "Registering project output for COM Interop...");
// create and initialize regasm task
RegAsmTask regasm = CreateRegAsmTask();
// add assembly references
foreach (ReferenceBase reference in References) {
StringCollection assemblyReferences = reference.GetAssemblyReferences(
solutionConfiguration);
foreach (string assemblyFile in assemblyReferences) {
regasm.References.Includes.Add(assemblyFile);
}
}
// assembly to register for COM interop
regasm.AssemblyFile = new FileInfo(config.BuildPath);
// type library to create
regasm.TypeLib = new FileInfo(typelibPath);
// increment indentation level
regasm.Project.Indent();
try {
// execute task
regasm.Execute();
} finally {
// restore indentation level
regasm.Project.Unindent();
}
}
///
/// Unregister a type library for the specified assembly, and the types
/// in that assembly.
///
/// The project configuration that is built.
/// The solution configuration that is built.
///
/// The regasm tool is used to unregister the type library, and
/// remove the COM registration for types in the specified assembly.
///
private void UnregisterForComInterop(ConfigurationSettings config, Configuration solutionConfiguration) {
// if COM interop registration is not enabled or the previous project
// output does not exist, then there's nothing to do
if (!config.RegisterForComInterop || !File.Exists(config.OutputPath)) {
return;
}
Log(Level.Verbose, "Unregistering project output for COM Interop...");
// create and initialize regasm task
RegAsmTask regasm = CreateRegAsmTask();
// add assembly references
foreach (ReferenceBase reference in References) {
StringCollection assemblyReferences = reference.GetAssemblyReferences(
solutionConfiguration);
foreach (string assemblyFile in assemblyReferences) {
regasm.References.Includes.Add(assemblyFile);
}
}
// unregister types
regasm.Unregister = true;
// assembly to unregister
regasm.AssemblyFile = new FileInfo(config.OutputPath);
// determine path for type library
string typeLibPath = GetTypeLibraryPath(config);
// if the type library exists, unregister it
if (File.Exists(typeLibPath)) {
regasm.TypeLib = new FileInfo(typeLibPath);
}
// increment indentation level
regasm.Project.Indent();
try {
regasm.Execute();
} finally {
// restore indentation level
regasm.Project.Unindent();
}
}
private void RegisterEmbeddedResource(string resourceFile, XmlElement elemFile) {
FileInfo fi = new FileInfo(resourceFile);
if (fi.Exists && string.Compare(".resx", fi.Extension, true) == 0 && fi.Length == 0) {
Log(Level.Verbose, "Skipping zero-byte embedded resource '{0}'.",
fi.FullName);
} else {
string dependentOn = (elemFile.Attributes["DependentUpon"] != null) ? FileUtils.CombinePaths(fi.DirectoryName, elemFile.Attributes["DependentUpon"].Value) : null;
Resource r = new Resource(this, fi, elemFile.Attributes["RelPath"].Value, dependentOn, SolutionTask, GacCache);
if (r.Culture != null) {
_localizedResources.Add(r);
} else {
_neutralResources.Add(r);
}
}
}
private void CompileResXFiles(Configuration solutionConfiguration) {
Log(Level.Verbose, "Compiling resources:");
Hashtable resxResources = new Hashtable();
// neutral resources
foreach (Resource resource in _neutralResources) {
if (!resource.IsResX) {
continue;
}
Log(Level.Verbose, " - {0}", resource.InputFile);
// determine filename of output file
FileInfo compiledResxFile = resource.GetCompiledResourceFile(solutionConfiguration);
// add to list of resx files to compile
resxResources.Add(resource, compiledResxFile);
}
// localized resources
foreach (Resource resource in _localizedResources) {
if (!resource.IsResX) {
continue;
}
Log(Level.Verbose, " - {0}", resource.InputFile);
// determine filename of output file
FileInfo compiledResxFile = resource.GetCompiledResourceFile(solutionConfiguration);
// add to list of resx files to compile
resxResources.Add(resource, compiledResxFile);
}
// no further processing required if there are no resx files to
// compile
if (resxResources.Count == 0) {
return;
}
// create instance of ResGen task
ResGenTask rt = new ResGenTask();
// inherit project from solution task
rt.Project = SolutionTask.Project;
// inherit namespace manager from solution task
rt.NamespaceManager = SolutionTask.NamespaceManager;
// parent is solution task
rt.Parent = SolutionTask;
// inherit verbose setting from solution task
rt.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
rt.InitializeTaskConfiguration();
// set parent of child elements
rt.Assemblies.Parent = rt;
// inherit project from solution task from parent task
rt.Assemblies.Project = rt.Project;
// inherit namespace manager from parent task
rt.Assemblies.NamespaceManager = rt.NamespaceManager;
// set base directory for filesets
rt.Assemblies.BaseDirectory = ProjectDirectory;
// set resx files to compile
foreach (DictionaryEntry entry in resxResources) {
Resource resource = (Resource) entry.Key;
FileInfo outputFile = (FileInfo) entry.Value;
QualifiedResource qualifiedResource = new QualifiedResource(
resource.InputFile, outputFile);
rt.QualifiedResources.Add(qualifiedResource);
}
// inherit assembly references from project
foreach (ReferenceBase reference in References) {
StringCollection assemblyReferences = reference.GetAssemblyReferences(
solutionConfiguration);
foreach (string assemblyFile in assemblyReferences) {
rt.Assemblies.Includes.Add(assemblyFile);
}
}
// increment indentation level
rt.Project.Indent();
try {
// execute task
rt.Execute();
} finally {
// restore indentation level
rt.Project.Unindent();
}
}
private void WriteNeutralResourceOptions(StreamWriter sw, Configuration solutionConfiguration) {
// no further processing required if there are no neutral resource
// files
if (_neutralResources.Count == 0) {
return;
}
foreach (Resource resource in _neutralResources) {
Log(Level.Verbose, " - {0}", resource.InputFile);
if (resource.IsResX) {
// determine filename of compiled file
FileInfo compiledResxFile = resource.GetCompiledResourceFile(solutionConfiguration);
// determine manifest resource name
string manifestResourceName = resource.GetManifestResourceName(
solutionConfiguration);
// write option to response file
sw.WriteLine(string.Format(CultureInfo.InvariantCulture,
"/res:\"{0}\",\"{1}\"", compiledResxFile.FullName,
manifestResourceName));
} else {
// compile resource
FileInfo compiledResourceFile = resource.Compile(
solutionConfiguration);
// write option to response file
sw.WriteLine(string.Format(CultureInfo.InvariantCulture,
"/res:\"{0}\",\"{1}\"", compiledResourceFile.FullName,
resource.GetManifestResourceName(solutionConfiguration)));
}
}
}
private bool PreBuild(ConfigurationSettings cs) {
string buildCommandLine = ProjectSettings.PreBuildEvent;
// check if there are pre build commands to be run
if (buildCommandLine != null) {
string batchFile = FileUtils.CombinePaths(cs.OutputDir.FullName, "PreBuildEvent.bat");
string workingDirectory = cs.OutputDir.FullName;
return ExecuteBuildEvent("PreBuildEvent", buildCommandLine,
batchFile, workingDirectory, cs);
}
// nothing to do, signal success
return true;
}
private bool PostBuild(ConfigurationSettings cs, bool bCompileSuccess, bool bOutputUpdated) {
string buildCommandLine = ProjectSettings.PostBuildEvent;
// check if there are post build commands to be run
if (buildCommandLine != null) {
Log(Level.Debug, "PostBuild commandline: {0}", buildCommandLine);
string batchFile = FileUtils.CombinePaths(cs.OutputDir.FullName, "PostBuildEvent.bat");
string workingDirectory = cs.OutputDir.FullName;
bool bBuildEventSuccess;
// there are three different settings for when the PostBuildEvent should be run
switch (ProjectSettings.RunPostBuildEvent) {
case "OnBuildSuccess":
// post-build event will run if the build succeeds. Thus,
// the event will even run for a project that is up-to-date,
// as long as the build succeeds
if (bCompileSuccess) {
Log(Level.Debug, "PostBuild+OnBuildSuccess+bCompileSuccess");
bBuildEventSuccess = ExecuteBuildEvent("PostBuildEvent",
buildCommandLine, batchFile, workingDirectory, cs);
} else {
Log(Level.Debug, "PostBuild+OnBuildSuccess");
bBuildEventSuccess = true;
}
break;
case "Always":
// post-build event will run regardless of whether the
// build succeeded
Log(Level.Debug, "PostBuild+Always");
bBuildEventSuccess = ExecuteBuildEvent("PostBuildEvent",
buildCommandLine, batchFile, workingDirectory, cs);
break;
case "OnOutputUpdated":
// post-build event will only run when the compiler's
// output file (.exe or .dll) is different than the
// previous compiler output file. Thus, a post-build
// event will not run if a project is up-to-date
if (bOutputUpdated) {
Log(Level.Debug, "PostBuild+OnOutputUpdated+bOutputUpdated");
bBuildEventSuccess = ExecuteBuildEvent("PostBuildEvent",
buildCommandLine, batchFile, workingDirectory, cs);
} else {
Log(Level.Debug, "PostBuild+OnOutputUpdated");
bBuildEventSuccess = true;
}
break;
default:
// getting here means unknown values in the RunPostBuildEvent
// property
bBuildEventSuccess = false;
break;
}
return bBuildEventSuccess;
}
// nothing to do, signal success
return true;
}
private bool CheckUpToDate(Configuration solutionConfiguration) {
DateTime dtOutputTimeStamp;
// obtain project configuration (corresponding with solution configuration)
ConfigurationSettings cs = (ConfigurationSettings) BuildConfigurations[solutionConfiguration];
// check if project build output exists
if (File.Exists(cs.BuildPath)) {
dtOutputTimeStamp = File.GetLastWriteTime(cs.BuildPath);
} else {
return false;
}
// check if project file was updated after the output file was
// built
string fileName = FileSet.FindMoreRecentLastWriteTime(ProjectPath,
dtOutputTimeStamp);
if (fileName != null) {
Log(Level.Debug, "Project file \"0\" has been updated, recompiling.",
fileName);
return false;
}
// check all of the input files
foreach (string file in _sourceFiles.Keys) {
if (dtOutputTimeStamp < File.GetLastWriteTime(file)) {
return false;
}
}
// check all culture-neutral resources
foreach (Resource resource in _neutralResources) {
// check if input file was updated since last compile
if (dtOutputTimeStamp < resource.InputFile.LastWriteTime) {
return false;
}
// check if compiled resource file exists
FileInfo compiledResourceFile = resource.GetCompiledResourceFile(solutionConfiguration);
if (!compiledResourceFile.Exists) {
return false;
}
// check if compiled resource file is up-to-date
if (dtOutputTimeStamp < compiledResourceFile.LastWriteTime) {
return false;
}
}
// check all of the input references
foreach (ReferenceBase reference in _references) {
if (dtOutputTimeStamp < reference.GetTimestamp(solutionConfiguration)) {
return false;
}
}
// check extra output files
foreach (DictionaryEntry de in cs.ExtraOutputFiles) {
string extraOutputFile = (string) de.Key;
// check if extra output file exists
if (!File.Exists(extraOutputFile)) {
return false;
}
}
return true;
}
///
/// Returns containing culture-specific resources.
///
///
/// A containing culture-specific resources.
///
///
/// The key of the is
/// and the value is an instance
/// for that culture.
///
private Hashtable GetLocalizedResources() {
Hashtable localizedResourceSets = new Hashtable();
foreach (Resource resource in _localizedResources) {
CultureInfo resourceCulture = resource.Culture;
LocalizedResourceSet resourceSet = (LocalizedResourceSet)
localizedResourceSets[resourceCulture];
if (resourceSet == null) {
resourceSet = new LocalizedResourceSet(resourceCulture);
localizedResourceSets.Add(resourceCulture, resourceSet);
}
resourceSet.Resources.Add(resource);
}
return localizedResourceSets;
}
///
/// Creates and initializes a instance.
///
///
/// An initialized instance.
///
private RegAsmTask CreateRegAsmTask() {
RegAsmTask regasm = new RegAsmTask();
// parent is solution task
regasm.Parent = SolutionTask;
// inherit project from solution task
regasm.Parent = regasm.Project = SolutionTask.Project;
// inherit verbose setting from solution task
regasm.Verbose = SolutionTask.Verbose;
// inherit namespace manager from solution task
regasm.NamespaceManager = SolutionTask.NamespaceManager;
// initialize framework configuration
regasm.InitializeTaskConfiguration();
// inherit project from parent task
regasm.Assemblies.Project = regasm.Project;
// set parent of child elements
regasm.Assemblies.Parent = regasm;
// inherit namespace manager from parent task
regasm.Assemblies.NamespaceManager = regasm.NamespaceManager;
// set base directory for filesets
regasm.Assemblies.BaseDirectory = ProjectDirectory;
// inherit project from parent task
regasm.References.Project = regasm.Project;
// set parent of child elements
regasm.References.Parent = regasm;
// inherit namespace manager from parent task
regasm.References.NamespaceManager = regasm.NamespaceManager;
// set base directory for filesets
regasm.References.BaseDirectory = ProjectDirectory;
// only output warning messages or higher, unless
// we're running in verbose mode
if (!regasm.Verbose) {
regasm.Threshold = Level.Warning;
}
return regasm;
}
#endregion Private Instance Methods
#region Public Static Methods
public static bool IsEnterpriseTemplateProject(string fileName) {
try {
using (StreamReader sr = new StreamReader(fileName, Encoding.Default, true)) {
XmlTextReader xtr = new XmlTextReader(sr);
xtr.MoveToContent();
if (xtr.NodeType == XmlNodeType.Element && xtr.LocalName == "EFPROJECT") {
return true;
}
}
return false;
} catch (XmlException) {
// when the project isn't a valid XML document, it definitely
// isn't an enterprise template project
return false;
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Error checking whether '{0}' is an enterprise template project.",
fileName), Location.UnknownLocation, ex);
}
}
public static string LoadGuid(XmlElement xmlDefinition)
{
XmlReader guidReader = new XmlNodeReader(xmlDefinition);
return LoadGuid(guidReader);
}
private static string LoadGuid(XmlReader guidReader) {
while (guidReader.Read()) {
if (guidReader.NodeType == XmlNodeType.Element) {
while (guidReader.Read()) {
if (guidReader.NodeType == XmlNodeType.Element) {
if (guidReader.MoveToAttribute( "ProjectGuid" ))
return guidReader.Value;
}
}
}
}
throw new BuildException("Couldn't locate project GUID.",
Location.UnknownLocation);
}
#endregion Public Static Methods
#region Protected Static Methods
///
/// Returns the Visual Studio product version of the specified project
/// XML fragment.
///
/// XML fragment representing the project to check.
///
/// The Visual Studio product version of the specified project XML
/// fragment.
///
///
/// The product version could not be determined.
/// -or-
/// The product version is not supported.
///
protected static ProductVersion GetProductVersion(XmlNode projectNode) {
if (projectNode == null) {
throw new ArgumentNullException("projectNode");
}
XmlAttribute productVersionAttribute = projectNode.Attributes["ProductVersion"];
if (productVersionAttribute == null) {
throw new BuildException("The \"ProductVersion\" attribute is"
+ " missing from the project node.", Location.UnknownLocation);
}
// check if we're dealing with a valid version number
Version productVersion = null;
try {
productVersion = new Version(productVersionAttribute.Value);
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"The value of the \"Version\" attribute ({0}) is not a valid"
+ " version string.", productVersionAttribute.Value),
Location.UnknownLocation, ex);
}
if (productVersion.Major == 7) {
switch (productVersion.Minor) {
case 0:
return ProductVersion.Rainier;
case 10:
return ProductVersion.Everett;
}
}
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Visual Studio version \"{0\" is not supported.",
productVersion.ToString()), Location.UnknownLocation);
}
///
/// Returns the of the specified project
/// XML fragment.
///
/// XML fragment representing the project to check.
///
/// The of the specified project XML
/// fragment.
///
///
/// The project location could not be determined.
/// -or-
/// The project location is invalid.
///
protected static ProjectLocation GetProjectLocation(XmlNode projectNode) {
if (projectNode == null) {
throw new ArgumentNullException("projectNode");
}
XmlAttribute projectTypeAttribute = projectNode.Attributes["ProjectType"];
if (projectTypeAttribute == null) {
throw new BuildException("The \"ProjectType\" attribute is"
+ " missing from the project node.", Location.UnknownLocation);
}
try {
return (ProjectLocation) Enum.Parse(typeof(ProjectLocation),
projectTypeAttribute.Value, true);
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"The value of the \"ProjectType\" attribute ({0}) is not a valid"
+ " location string.", projectTypeAttribute.Value),
Location.UnknownLocation, ex);
}
}
#endregion Protected Static Methods
#region Private Instance Fields
private ArrayList _references;
///
/// Holds a case-insensitive list of source files.
///
///
/// The key of the is the full path of the
/// source file and the value is .
///
private readonly Hashtable _sourceFiles;
private readonly ArrayList _neutralResources;
private readonly ArrayList _localizedResources;
private readonly string _projectPath;
private readonly DirectoryInfo _projectDirectory;
private readonly string _webProjectBaseUrl;
private readonly ProjectSettings _projectSettings;
private readonly ProjectLocation _projectLocation;
#endregion Private Instance Fields
#region Private Static Fields
private const string CommandFile = "compile-commands.txt";
#endregion Private Static Fields
///
/// Groups a set of instances for a specific
/// culture.
///
private class LocalizedResourceSet {
#region Private Instance Fields
private readonly CultureInfo _culture;
private readonly ArrayList _resources;
#endregion Private Instance Fields
#region Public Instance Constructors
///
/// Initializes a new instance
/// for the specified culture.
///
/// A .
public LocalizedResourceSet(CultureInfo culture) {
if (culture == null) {
throw new ArgumentNullException("culture");
}
_culture = culture;
_resources = new ArrayList();
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets the of the
/// .
///
public CultureInfo Culture {
get { return _culture; }
}
///
/// Gets the set of localized resources.
///
public ArrayList Resources {
get { return _resources; }
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Gets the intermediate build directory in which the satellite
/// assembly is built.
///
/// The project build configuration.
///
/// The intermediate build directory in which the satellite assembly
/// is built.
///
public DirectoryInfo GetBuildDirectory(ConfigurationSettings projectConfig) {
return new DirectoryInfo(FileUtils.CombinePaths(
projectConfig.ObjectDir.FullName, Culture.Name));
}
///
/// Gets a representing the path to the
/// intermediate file location of the satellite assembly.
///
/// The project build configuration.
/// The project settings.
///
/// A representing the path to the
/// intermediate file location of the satellite assembly.
///
public FileInfo GetSatelliteAssemblyPath(ConfigurationSettings projectConfig, ProjectSettings projectSettings) {
DirectoryInfo buildDir = GetBuildDirectory(projectConfig);
return new FileInfo(FileUtils.CombinePaths(buildDir.FullName,
GetSatelliteFileName(projectSettings)));
}
///
/// Gets path of the satellite assembly, relative to the output
/// directory.
///
/// The project settings.
///
/// The path of the satellite assembly, relative to the output
/// directory.
///
public string GetRelativePath(ProjectSettings projectSettings) {
return FileUtils.CombinePaths(Culture.Name, GetSatelliteFileName(
projectSettings));
}
#endregion Public Instance Methods
#region Private Instance Methods
private string GetSatelliteFileName(ProjectSettings projectSettings) {
return string.Format(CultureInfo.InvariantCulture,
"{0}.resources.dll", projectSettings.AssemblyName);
}
#endregion Private Instance Methods
}
}
///
/// Indentifies the different output types of a managed project.
///
///
/// Visual Studio .NET does not support modules.
///
public enum ManagedOutputType {
///
/// A class library.
///
Library = 1,
///
/// A console application.
///
Executable = 2,
///
/// A Windows program.
///
WindowsExecutable = 3
}
}
nant-0.92-rc1/src/NAnt.VSNet/VcAssemblyReference.cs 0000644 0001750 0001750 00000016634 11757302274 021706 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
public class VcAssemblyReference : AssemblyReferenceBase {
public VcAssemblyReference(XmlElement xmlDefinition, ReferencesResolver referencesResolver, ProjectBase parent, GacCache gacCache) : base(xmlDefinition, referencesResolver, parent, gacCache) {
XmlAttribute privateAttribute = xmlDefinition.Attributes["CopyLocal"];
if (privateAttribute != null) {
_isPrivateSpecified = true;
_isPrivate = bool.Parse(privateAttribute.Value);
}
// determine name of reference by taking filename part of relative
// path, without extension
XmlAttribute relativePathAttribute = XmlDefinition.Attributes["RelativePath"];
if (relativePathAttribute != null) {
_name = Path.GetFileNameWithoutExtension(relativePathAttribute.Value);
}
_assemblyFile = ResolveAssemblyReference();
}
#region Override implementation of AssemblyReferenceBase
protected override bool IsPrivate {
get { return _isPrivate; }
}
protected override bool IsPrivateSpecified {
get { return _isPrivateSpecified; }
}
///
/// Resolves an assembly reference.
///
///
/// The full path to the resolved assembly, or
/// if the assembly reference could not be resolved.
///
protected override string ResolveAssemblyReference() {
// check if assembly reference was resolved before
if (_assemblyFile != null) {
// if assembly file actually exists, there's no need to resolve
// the assembly reference again
if (File.Exists(_assemblyFile)) {
return _assemblyFile;
}
}
XmlElement referenceElement = XmlDefinition;
string assemblyFileName = null;
string relativePath = referenceElement.GetAttribute("RelativePath");
if (relativePath == null) {
throw new BuildException("For Visual C++ projects only assembly"
+ " references using relative paths are supported.",
Location.UnknownLocation);
} else {
// expand macro's in RelativePath
assemblyFileName = _rxMacro.Replace(relativePath,
new MatchEvaluator(EvaluateMacro));
// TODO: support locating assemblies in VCConfiguration.ReferencesPath,
// but for now just remove it from reference filename and
// search all assembly folders
assemblyFileName = assemblyFileName.Replace("{ReferencesPath}\\",
string.Empty);
}
// 1. The RelativePath might be fully qualified (after macro expansion)
if (Path.IsPathRooted(assemblyFileName)) {
// consider assembly resolve although we're not sure whether
// the file actually exists
//
// the file might actually be created as result of building
// a project
return assemblyFileName;
}
// 2. The project directory
// NOT SURE IF THIS IS CORRECT
// 3. The ReferencePath
// NOT SURE WE SHOULD DO THIS ONE
// 4. The .NET Framework directory
string resolvedAssemblyFile = ResolveFromFramework(assemblyFileName);
if (resolvedAssemblyFile != null) {
return resolvedAssemblyFile;
}
// 5. AssemblyFolders
resolvedAssemblyFile = ResolveFromAssemblyFolders(referenceElement,
Path.GetFileName(assemblyFileName));
if (resolvedAssemblyFile != null) {
return resolvedAssemblyFile;
}
// assembly reference could not be resolved
return null;
}
#endregion Override implementation of AssemblyReferenceBase
#region Override implementation of ReferenceBase
///
/// Gets the name of the referenced assembly.
///
///
/// The name of the referenced assembly, or if
/// the name could not be determined.
///
public override string Name {
get { return _name; }
}
#endregion Override implementation of ReferenceBase
#region Private Instance Methods
///
/// Is called each time a regular expression match is found during a
/// operation.
///
/// The resulting from a single regular expression match during a .
///
/// The expanded .
///
/// The macro is not supported.
/// Expansion of a given macro is not yet implemented.
private string EvaluateMacro(Match m) {
string macro = m.Groups[1].Value;
// expand using solution level macro's
string expandedMacro = SolutionTask.ExpandMacro(macro);
if (expandedMacro != null) {
return expandedMacro;
}
// expand using project level macro's
expandedMacro = Parent.ExpandMacro(macro);
if (expandedMacro != null) {
return expandedMacro;
}
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Macro \"{0}\", used by assembly reference \"{1}\" in project"
+ " \"{2}\" is not supported in assembly references.", macro,
Name, Parent.Name), Location.UnknownLocation);
}
#endregion Private Instance Methods
#region Private Instance Fields
private string _assemblyFile;
private readonly bool _isPrivateSpecified;
private readonly bool _isPrivate;
private readonly string _name = string.Empty;
private readonly Regex _rxMacro = new Regex(@"\$\((\w+)\)");
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/VcProjectReference.cs 0000644 0001750 0001750 00000007716 11757302274 021536 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
namespace NAnt.VSNet {
public class VcProjectReference : ProjectReferenceBase {
#region Public Instance Constructors
public VcProjectReference(XmlElement xmlDefinition, ReferencesResolver referencesResolver, ProjectBase parent, SolutionBase solution, TempFileCollection tfc, GacCache gacCache, DirectoryInfo outputDir) : base(referencesResolver, parent) {
if (xmlDefinition == null) {
throw new ArgumentNullException("xmlDefinition");
}
if (solution == null) {
throw new ArgumentNullException("solution");
}
if (tfc == null) {
throw new ArgumentNullException("tfc");
}
if (gacCache == null) {
throw new ArgumentNullException("gacCache");
}
XmlAttribute privateAttribute = xmlDefinition.Attributes["CopyLocal"];
if (privateAttribute != null) {
_isPrivateSpecified = true;
_isPrivate = bool.Parse(privateAttribute.Value);
}
// determine path of project file
string projectFile = solution.GetProjectFileFromGuid(
xmlDefinition.GetAttribute("ReferencedProjectIdentifier"));
// load referenced project
_project = LoadProject(solution, tfc, gacCache, outputDir, projectFile);
}
public VcProjectReference(ProjectBase project, ProjectBase parent, bool isPrivateSpecified, bool isPrivate) : base(project.ReferencesResolver, parent) {
_project = project;
_isPrivateSpecified = isPrivateSpecified;
_isPrivate = isPrivate;
}
#endregion Public Instance Constructors
#region Override implementation of ReferenceBase
///
/// Gets a value indicating whether the reference is managed for the
/// specified configuration.
///
/// The build configuration of the reference.
///
/// if the reference is managed for the
/// specified configuration; otherwise, .
///
public override bool IsManaged(Configuration config) {
return Project.IsManaged(config);
}
#endregion Override implementation of ReferenceBase
#region Override implementation of ProjectReferenceBase
public override ProjectBase Project {
get { return _project; }
}
protected override bool IsPrivate {
get { return _isPrivate; }
}
protected override bool IsPrivateSpecified {
get { return _isPrivateSpecified; }
}
#endregion Override implementation of ProjectReferenceBase
#region Private Instance Fields
private readonly ProjectBase _project;
private readonly bool _isPrivateSpecified;
private readonly bool _isPrivate;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/SolutionFactory.cs 0000644 0001750 0001750 00000007226 11757302274 021160 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Extensibility;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
///
/// Factory class for VS.NET solutions.
///
internal sealed class SolutionFactory {
#region Private Instance Constructor
///
/// Initializes a new instance of the
/// class.
///
private SolutionFactory() {
}
#endregion Private Instance Constructor
#region Internal Static Methods
internal static SolutionFactory Create () {
return new SolutionFactory();
}
#endregion Internal Static Methods
#region Public Instance Methods
public SolutionBase LoadSolution(SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver) {
if (solutionTask.SolutionFile == null) {
return new GenericSolution(solutionTask, tfc, gacCache, refResolver);
} else {
// determine the solution file format version
// will hold the content of the solution file
string fileContents;
using (StreamReader sr = new StreamReader(solutionTask.SolutionFile.FullName, Encoding.Default, true)) {
fileContents = sr.ReadToEnd();
}
ISolutionBuildProvider provider = FindProvider(fileContents);
if (provider != null) {
return provider.GetInstance(fileContents, solutionTask, tfc, gacCache, refResolver);
}
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Solution format of file '{0}' is not supported.", solutionTask.SolutionFile),
Location.UnknownLocation);
}
}
public void RegisterProvider(ISolutionBuildProvider provider) {
_projectProviders.Add(provider);
}
#endregion Public Instance Methods
#region Private Instance Methods
private ISolutionBuildProvider FindProvider(string fileContents) {
int max = 0;
ISolutionBuildProvider res = null;
foreach (ISolutionBuildProvider provider in _projectProviders) {
int pri = provider.IsSupported(fileContents);
if (pri > max) {
max = pri;
res = provider;
}
}
return res;
}
#endregion Private Instance Methods
private readonly ArrayList _projectProviders = new ArrayList();
}
}
nant-0.92-rc1/src/NAnt.VSNet/AssemblyReferenceBase.cs 0000644 0001750 0001750 00000030012 11757302274 022172 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
// Scott Ford (sford@RJKTECH.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Xml;
using Microsoft.Win32;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
public abstract class AssemblyReferenceBase : FileReferenceBase {
#region Protected Instance Constructors
protected AssemblyReferenceBase(XmlElement xmlDefinition, ReferencesResolver referencesResolver, ProjectBase parent, GacCache gacCache) : base(xmlDefinition, referencesResolver, parent, gacCache) {
}
#endregion Protected Instance Constructors
#region Protected Instance Properties
protected abstract bool IsPrivate {
get;
}
protected abstract bool IsPrivateSpecified {
get;
}
#endregion Protected Instance Properties
#region Override implementation of ReferenceBase
///
/// Gets a value indicating whether the output file(s) of this reference
/// should be copied locally.
///
///
/// if the output file(s) of this reference
/// should be copied locally; otherwise, .
///
public override bool CopyLocal {
get {
if (IsPrivateSpecified) {
return IsPrivate;
} else {
// only copy local if assembly reference could be resolved,
// if not a system assembly and is not in the GAC
string assemblyFile = ResolveAssemblyReference();
return assemblyFile != null && !IsSystem &&
!GacCache.IsAssemblyInGac(assemblyFile);
}
}
}
///
/// Gets a value indicating whether this reference represents a system
/// assembly.
///
///
/// if this reference represents a system
/// assembly; otherwise, .
///
protected override bool IsSystem {
get {
// if the assembly cannot be resolved, we consider it not to
// be a system assembly
string assemblyFile = ResolveAssemblyReference();
if (assemblyFile == null) {
return false;
}
// check if assembly is stored in the framework assembly
// directory
return string.Compare(Path.GetDirectoryName(assemblyFile),
SolutionTask.Project.TargetFramework.FrameworkAssemblyDirectory.FullName,
true, CultureInfo.InvariantCulture) == 0;
}
}
///
/// Gets the path of the reference, without taking the "copy local"
/// setting into consideration.
///
/// The solution configuration that is built.
///
/// The output path of the reference.
///
public override string GetPrimaryOutputFile(Configuration solutionConfiguration) {
return ResolveAssemblyReference();
}
///
/// Gets the complete set of output files for the referenced project.
///
/// The solution configuration that is built.
/// The set of output files to be updated.
///
/// The key of the case-insensitive is the
/// full path of the output file and the value is the path relative to
/// the output directory.
///
public override void GetOutputFiles(Configuration solutionConfiguration, Hashtable outputFiles) {
string assemblyFile = ResolveAssemblyReference();
if (assemblyFile != null) {
base.GetAssemblyOutputFiles(assemblyFile, outputFiles);
}
}
///
/// Gets the complete set of assemblies that need to be referenced when
/// a project references this component.
///
/// The solution configuration that is built.
///
/// The complete set of assemblies that need to be referenced when a
/// project references this component.
///
public override StringCollection GetAssemblyReferences(Configuration solutionConfiguration) {
// if we're dealing with an assembly reference, then we only
// need to reference that assembly itself as VS.NET forces users
// to add all dependent assemblies to the project itself
StringCollection assemblyReferences = new StringCollection();
// attempt to resolve assembly reference
string assemblyFile = ResolveAssemblyReference();
if (assemblyFile == null) {
Log(Level.Warning, "Assembly \"{0}\", referenced"
+ " by project \"{1}\", could not be resolved.", Name,
Parent.Name);
return assemblyReferences;
}
// ensure assembly actually exists
if (!File.Exists(assemblyFile)) {
Log(Level.Warning, "Assembly \"{0}\", referenced"
+ " by project \"{1}\", does not exist.", assemblyFile,
Parent.Name);
return assemblyReferences;
}
// add referenced assembly to list of reference assemblies
assemblyReferences.Add(assemblyFile);
return assemblyReferences;
}
///
/// Gets the timestamp of the reference.
///
/// The solution configuration that is built.
///
/// The timestamp of the reference.
///
public override DateTime GetTimestamp(Configuration solutionConfiguration) {
string assemblyFile = ResolveAssemblyReference();
if (assemblyFile == null) {
return DateTime.MaxValue;
}
return GetFileTimestamp(assemblyFile);
}
#endregion Override implementation of ReferenceBase
#region Public Instance Methods
public ProjectReferenceBase CreateProjectReference(ProjectBase project) {
return project.CreateProjectReference(project, IsPrivateSpecified,
IsPrivate);
}
#endregion Public Instance Methods
#region Protected Instance Methods
///
/// Resolves an assembly reference.
///
///
/// The full path to the resolved assembly, or
/// if the assembly reference could not be resolved.
///
protected abstract string ResolveAssemblyReference();
///
/// Searches for the given file in all paths in .
///
/// The folders to search.
/// The file to search for.
///
/// The path of the assembly if was found
/// in ; otherwise, .
///
protected string ResolveFromFolderList(StringCollection folderList, string fileName) {
Log(Level.Debug, "Attempting to resolve \"{0}\" in AssemblyFolders...",
fileName);
foreach (string path in folderList) {
Log(Level.Debug, "Checking \"{0}\"...", path);
try {
string assemblyFile = FileUtils.CombinePaths(path, fileName);
if (File.Exists(assemblyFile)) {
Log(Level.Debug, "Assembly found in \"{0}\".", path);
return assemblyFile;
} else {
Log(Level.Debug, "Assembly not found in \"{0}\".", path);
}
} catch (Exception ex) {
Log(Level.Verbose, "Error resolving reference to \"{0}\""
+ " in directory \"{1}\".", fileName, path);
Log(Level.Debug, ex.ToString());
}
}
return null;
}
///
/// Resolves an assembly reference in the framework assembly directory
/// of the target framework.
///
/// The file to search for.
///
/// The full path of the assembly file if the assembly could be located
/// in the framework assembly directory; otherwise, .
///
protected string ResolveFromFramework(string fileName) {
//string systemAssembly = FileUtils.CombinePaths(SolutionTask.Project.TargetFramework.
// FrameworkAssemblyDirectory.FullName, fileName);
string systemAssembly = SolutionTask.Project.TargetFramework.ResolveAssembly(fileName);
if (File.Exists(systemAssembly)) {
return systemAssembly;
}
return null;
}
///
/// Resolves an assembly reference using a path relative to the project
/// directory.
///
///
/// The full path of the assembly, or if
/// is or an
/// empty .
///
protected string ResolveFromRelativePath(string relativePath) {
if (!String.IsNullOrEmpty(relativePath)) {
// TODO: VS.NET seems to be able to handle a project dir / hint
// path combination that is more than 260 characters long
//
// eg. ../Assemblies/..Assemblies/../......
string combinedPath = FileUtils.CombinePaths(Parent.ProjectDirectory.FullName,
relativePath);
try {
return FileUtils.GetFullPath(combinedPath);
} catch (PathTooLongException ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Assembly \"{0}\", referenced by project \"{1}\", could not be"
+ " resolved using path \"{2}\".", Name, Parent.Name, combinedPath),
Location.UnknownLocation, ex);
}
}
return null;
}
protected virtual string ResolveFromAssemblyFolders(XmlElement referenceElement, string fileName) {
return ResolveFromFolderList(SolutionTask.AssemblyFolderList,
fileName);
}
#endregion Protected Instance Methods
}
}
nant-0.92-rc1/src/NAnt.VSNet/AssemblyInfo.cs 0000644 0001750 0001750 00000002332 11757302274 020400 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Scott Hernandez (ScottHernandez@hotmail.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System.Reflection;
// This will not compile with Visual Studio. If you want to build a signed
// executable use the NAnt build file. To build under Visual Studio just
// exclude this file from the build.
[assembly: AssemblyDelaySign(false)]
//[assembly: AssemblyKeyFile(@"..\NAnt.key")]
[assembly: AssemblyKeyName("")] nant-0.92-rc1/src/NAnt.VSNet/CSharpProjectProvider.cs 0000644 0001750 0001750 00000003711 11757302274 022231 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2006 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Martin Aliger (martin_aliger@myrealbox.com)
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Extensibility;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
internal class CSharpProjectProvider : IProjectBuildProvider {
#region Implementation of IProjectBuildProvider
public int IsSupported(string projectExt, XmlElement xmlDefinition) {
if (projectExt == ".csproj")
return 5;
if (CSharpProject.IsSupported(xmlDefinition))
return 10;
return 0;
}
public ProjectBase GetInstance(SolutionBase solution, string projectPath, XmlElement xmlDefinition, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver, DirectoryInfo outputDir) {
return new CSharpProject(solution, projectPath, xmlDefinition, solutionTask, tfc, gacCache, refResolver, outputDir);
}
public string LoadGuid(XmlElement xmlDefinition) {
return CSharpProject.LoadGuid(xmlDefinition);
}
#endregion Implementation of IProjectBuildProvider
}
}
nant-0.92-rc1/src/NAnt.VSNet/NAnt.VSNet.csproj 0000644 0001750 0001750 00000015647 11757302274 020553 0 ustar jtaylor jtaylor
DebugAnyCPU2.0{DD434690-B4DF-4BF9-91FE-F139A41E2474}NAnt.VSNetNAnt.VSNetTasksLibraryOnSuccessfulBuildfalse8.0.50727v2.02.0publish\trueDiskfalseForeground7Daysfalsefalsetrue01.0.0.%2afalsefalsetruetruefullfalse4..\..\build\Debug\AllRules.rulesetTRACE;DEBUG..\..\build\Debug\NAnt.VSNetTasks.xmltruepdbonlytrue..\..\build\Release\4AllRules.rulesetTRACE..\..\build\Release\NAnt.VSNetTasks.xml
CommonAssemblyInfo.cs
False.NET Framework 3.5 SP1 Client ProfilefalseFalse.NET Framework 3.5 SP1trueFalseWindows Installer 3.1true{8F5F8375-4097-4952-B860-784EB9961ABE}NAnt.Core{B50A1067-785B-4686-8FFC-5AF424BEF163}NAnt.DotNet{A154DB17-7263-44E3-838E-1E4C4946B7D8}NAnt.VisualCpp{C66545A2-6FEC-4A38-937A-5B25E61EE8A1}NAnt.Win32 nant-0.92-rc1/src/NAnt.VSNet/Rainier/ 0000755 0001750 0001750 00000000000 11757310030 017034 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.VSNet/Rainier/SolutionProvider.cs 0000644 0001750 0001750 00000004063 11757302274 022730 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Martin Aliger (martin_aliger@myrealbox.com)
using System;
using System.CodeDom.Compiler;
using System.Text.RegularExpressions;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Extensibility;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet.Rainier {
internal class SolutionProvider : ISolutionBuildProvider {
#region Implementation of ISolutionBuildProvider
public int IsSupported(string fileContents) {
Regex reSolutionFormat = new Regex(@"^\s*Microsoft Visual Studio Solution File, Format Version\s+(?[0-9]+\.[0-9]+)", RegexOptions.Singleline);
MatchCollection matches = reSolutionFormat.Matches(fileContents);
if (matches.Count == 0) {
return 0;
}
string formatVersion = matches[0].Groups["formatVersion"].Value;
if (formatVersion == "7.00") {
return 10;
}
return 0;
}
public SolutionBase GetInstance(string solutionContent, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver) {
return new Solution(solutionContent, solutionTask, tfc, gacCache, refResolver);
}
#endregion Implementation of ISolutionBuildProvider
}
}
nant-0.92-rc1/src/NAnt.VSNet/Rainier/Solution.cs 0000644 0001750 0001750 00000013405 11757302274 021215 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet.Rainier {
///
/// Analyses Microsoft Visual Studio .NET 2002 (Rainier) solution files.
///
internal class Solution : SolutionBase {
public Solution(string solutionContent, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver) : base(solutionTask, tfc, gacCache, refResolver) {
Regex reProjects = new Regex(@"Project\(\""(?\{.*?\})\"".*?\""(?.*?)\"".*?\""(?.*?)\"".*?\""(?.*?)\""(?[\s\S]*?)EndProject", RegexOptions.Multiline);
MatchCollection projectMatches = reProjects.Matches(solutionContent);
Hashtable explicitProjectDependencies = CollectionsUtil.CreateCaseInsensitiveHashtable();
foreach (Match projectMatch in projectMatches) {
string project = projectMatch.Groups["project"].Value;
string guid = projectMatch.Groups["guid"].Value;
// translate partial project path or URL to absolute path
string fullProjectPath = TranslateProjectPath(solutionTask.SolutionFile.DirectoryName,
project);
// check if project file actually exists
if (!System.IO.File.Exists(fullProjectPath)) {
throw CreateProjectDoesNotExistException(fullProjectPath);
}
if (ManagedProjectBase.IsEnterpriseTemplateProject(fullProjectPath)) {
RecursiveLoadTemplateProject(fullProjectPath);
} else {
// add project path to collection
ProjectEntries.Add(new ProjectEntry(guid, fullProjectPath));
}
// set-up project dependencies
Regex reDependencies = new Regex(@"^\s+" + guid + @"\.[0-9]+ = (?\{\S*\}?)\s*$", RegexOptions.Multiline);
MatchCollection dependencyMatches = reDependencies.Matches(solutionContent);
foreach (Match dependencyMatch in dependencyMatches) {
string dependency = dependencyMatch.Groups["dep"].Value;
if (!explicitProjectDependencies.ContainsKey(guid)) {
explicitProjectDependencies[guid] = CollectionsUtil.CreateCaseInsensitiveHashtable();
}
((Hashtable) explicitProjectDependencies[guid])[dependency] = null;
}
// set-up project configuration
Regex reProjectBuildConfig = new Regex(@"^\s+" + guid + @"\.(?[^|]+)\|?(?[^\.]?)\.Build\.0\s*=\s*(?[^|]+)\|(?[\.\w ]+)\s*", RegexOptions.Multiline);
MatchCollection projectBuildMatches = reProjectBuildConfig.Matches(solutionContent);
ProjectEntry projectEntry = ProjectEntries [guid];
if (projectEntry == null) {
// TODO: determine if we should report an error if a build
// configuration is defined for a project that does not
// exist in the solution
continue;
}
// holds mapping between project configuration(s) and solution(s)
ConfigurationMap buildConfigurations = new ConfigurationMap(
projectBuildMatches.Count);
for (int i = 0; i < projectBuildMatches.Count; i++) {
Match projectBuildMatch = projectBuildMatches [i];
string solutionConfigName = projectBuildMatch.Groups["solutionConfiguration"].Value;
string solutionPlatform = projectBuildMatch.Groups["solutionPlatform"].Value;
string projectConfigName = projectBuildMatch.Groups["projectConfiguration"].Value;
string projectPlatform = projectBuildMatch.Groups["projectPlatform"].Value;
Configuration solutionConfig = new Configuration(
solutionConfigName, solutionPlatform);
Configuration projectConfig = new Configuration(
projectConfigName, projectPlatform);
buildConfigurations [solutionConfig] = projectConfig;
}
// add map to corresponding project entry
projectEntry.BuildConfigurations = buildConfigurations;
}
LoadProjectGuids(new ArrayList(solutionTask.Projects.FileNames), false);
LoadProjectGuids(new ArrayList(solutionTask.ReferenceProjects.FileNames), true);
LoadProjects(gacCache, refResolver, explicitProjectDependencies);
}
}
}
nant-0.92-rc1/src/NAnt.VSNet/ConfigurationSettings.cs 0000644 0001750 0001750 00000024037 11757302274 022343 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
using System;
using System.Globalization;
using System.IO;
using System.Collections;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
public class ConfigurationSettings : ConfigurationBase {
#region Public Instance Constructors
public ConfigurationSettings(ManagedProjectBase project, XmlElement elemConfig, DirectoryInfo outputDir) : base(project) {
_settings = new ArrayList();
if (outputDir == null) {
_relativeOutputDir = elemConfig.Attributes["OutputPath"].Value;
if (!_relativeOutputDir.EndsWith(Path.DirectorySeparatorChar.ToString(CultureInfo.InvariantCulture))) {
_relativeOutputDir = _relativeOutputDir + Path.DirectorySeparatorChar;
}
_outputDir = new DirectoryInfo(FileUtils.CombinePaths(
project.ProjectDirectory.FullName,
_relativeOutputDir));
} else {
_relativeOutputDir = outputDir.FullName;
if (!_relativeOutputDir.EndsWith(Path.DirectorySeparatorChar.ToString(CultureInfo.InvariantCulture))) {
_relativeOutputDir = _relativeOutputDir + Path.DirectorySeparatorChar;
}
_outputDir = outputDir;
}
_name = elemConfig.GetAttribute("Name");
string documentationFile = elemConfig.GetAttribute("DocumentationFile");
if (!String.IsNullOrEmpty(documentationFile)) {
// to match VS.NET, the XML Documentation file will be output
// in the project directory, and only later copied to the output
// directory
string xmlDocBuildFile = FileUtils.CombinePaths(project.ProjectDirectory.FullName,
documentationFile);
// add compiler option to build XML Documentation file
_settings.Add(@"/doc:""" + xmlDocBuildFile + @"""");
// make sure the output directory for the doc file exists
if (!Directory.Exists(Path.GetDirectoryName(xmlDocBuildFile))) {
Directory.CreateDirectory(Path.GetDirectoryName(xmlDocBuildFile));
}
// add built documentation file as extra output file
ExtraOutputFiles[xmlDocBuildFile] = Path.GetFileName(xmlDocBuildFile);
}
// determine whether we need to register project output for use with
// COM components
_registerForComInterop = string.Compare(elemConfig.GetAttribute("RegisterForComInterop"),
"true", true, CultureInfo.InvariantCulture) == 0;
SolutionTask.Log(Level.Debug, "Project: {0} Relative Output Path: {1} Output Path: {2} Documentation Path: {3}",
Project.Name, _relativeOutputDir, _outputDir.FullName, documentationFile);
Hashtable htStringSettings = new Hashtable();
Hashtable htBooleanSettings = new Hashtable();
htStringSettings["BaseAddress"] = "/baseaddress:{0}";
// is only supported by csc (all versions) and vbc (2.0 or higher)
htStringSettings["FileAlignment"] = "/filealign:{0}";
htStringSettings["DefineConstants"] = "/define:{0}";
switch (project.Type) {
case ProjectType.CSharp:
htStringSettings["WarningLevel"] = "/warn:{0}";
htStringSettings["NoWarn"] = "/nowarn:{0}";
htBooleanSettings["IncrementalBuild"] = "/incremental";
htBooleanSettings["AllowUnsafeBlocks"] = "/unsafe";
htBooleanSettings["CheckForOverflowUnderflow"] = "/checked";
break;
case ProjectType.JSharp:
htStringSettings["WarningLevel"] = "/warn:{0}";
htStringSettings["NoWarn"] = "/nowarn:{0}";
htBooleanSettings["IncrementalBuild"] = "/incremental";
break;
case ProjectType.VB:
htStringSettings["DefineDebug"] = "/d:DEBUG={0}";
htStringSettings["DefineTrace"] = "/d:TRACE={0}";
htBooleanSettings["RemoveIntegerChecks"] = "/removeintchecks";
break;
}
htBooleanSettings["DebugSymbols"] = "/debug";
htBooleanSettings["TreatWarningsAsErrors"] = "/warnaserror";
htBooleanSettings["Optimize"] = "/optimize";
foreach (DictionaryEntry de in htStringSettings) {
string name = de.Key.ToString();
string value = elemConfig.GetAttribute(de.Key.ToString());
if (!String.IsNullOrEmpty(value)) {
switch (name) {
case "BaseAddress":
// vbc and vjs expect the base address to be specified
// as a hexadecimal number, csc supports decimal,
// hexadecimal, or octal number
//
// so use hexadecimal as all compiler support this
uint intvalue = Convert.ToUInt32(value, CultureInfo.InvariantCulture);
value = "0x" + intvalue.ToString("x", CultureInfo.InvariantCulture);
break;
case "DefineConstants":
// vbc fails when the symbol contains spaces
value = value.Replace(" ", string.Empty);
break;
}
_settings.Add(string.Format(CultureInfo.InvariantCulture, de.Value.ToString(), value));
}
}
foreach (DictionaryEntry de in htBooleanSettings) {
string name = de.Key.ToString();
switch (name) {
case "IncrementalBuild":
// ignore if not supported
if (!IncrementalBuildSupported) {
continue;
}
break;
}
string value = elemConfig.GetAttribute(name);
if (string.Compare(value, "true", true, CultureInfo.InvariantCulture) == 0) {
_settings.Add(de.Value.ToString() + "+");
} else if (string.Compare(value, "false", true, CultureInfo.InvariantCulture) == 0) {
_settings.Add(de.Value.ToString() + "-");
}
}
_settings.Add(string.Format(CultureInfo.InvariantCulture, "/out:\"{0}\"", BuildPath));
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets the platform that the configuration targets.
///
///
/// The platform targeted by the configuration.
///
public override string PlatformName {
get { return ".NET"; }
}
public override string RelativeOutputDir {
get { return _relativeOutputDir; }
}
public override DirectoryInfo OutputDir {
get { return _outputDir; }
}
public override string OutputPath {
get {
return FileUtils.CombinePaths(OutputDir.FullName,
((ManagedProjectBase) Project).ProjectSettings.OutputFileName);
}
}
///
/// Gets the path in which the output file will be created before its
/// copied to the actual output path.
///
public override string BuildPath {
get {
return FileUtils.CombinePaths(ObjectDir.FullName,
Path.GetFileName(OutputPath));
}
}
public string[] Settings {
get { return (string[]) _settings.ToArray(typeof(string)); }
}
public override string Name {
get { return _name; }
}
///
/// Gets a value indicating whether to register the project output for
/// use with COM components.
///
///
/// if the project output should be registered
/// for use with COM components; otherwise, .
///
public bool RegisterForComInterop {
get { return _registerForComInterop; }
}
#endregion Public Instance Properties
#region Private Instance Properties
private bool IncrementalBuildSupported {
get {
FrameworkInfo tf = SolutionTask.Project.TargetFramework;
// only supported up until .NET Framework 2.0
return (tf.Family == "net" && tf.Version <= new Version (2, 0));
}
}
#endregion Private Instance Properties
#region Private Instance Fields
private readonly ArrayList _settings;
private readonly string _relativeOutputDir;
private readonly DirectoryInfo _outputDir;
private readonly string _name;
private readonly bool _registerForComInterop;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/VBProject.cs 0000644 0001750 0001750 00000022644 11757302274 017653 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.CodeDom.Compiler;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.DotNet.Types;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
public class VBProject : ManagedProjectBase {
#region Public Instance Constructors
public VBProject(SolutionBase solution, string projectPath, XmlElement xmlDefinition, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver, DirectoryInfo outputDir) : base(solution, projectPath, xmlDefinition, solutionTask, tfc, gacCache, refResolver, outputDir) {
_imports = new NamespaceImportCollection();
// process namespace imports
XmlNodeList imports = xmlDefinition.SelectNodes("//Imports/Import");
foreach (XmlElement import in imports) {
XmlAttribute nsAttribute = import.Attributes["Namespace"];
if (nsAttribute != null) {
string nameSpace = nsAttribute.Value.ToString(
CultureInfo.InvariantCulture);
_imports.Add(new NamespaceImport(nameSpace));
}
}
}
#endregion Public Instance Constructors
#region Override implementation of ManagedProjectBase
protected override void WriteProjectOptions(StreamWriter sw) {
// write namespace imports
if (_imports.Count > 0) {
sw.WriteLine("/imports:{0}", _imports.ToString());
}
}
#endregion Override implementation of ManagedProjectBase
#region Override implementation of ProjectBase
///
/// Gets the type of the project.
///
///
/// The type of the project.
///
public override ProjectType Type {
get { return ProjectType.VB; }
}
///
/// Verifies whether the specified XML fragment represents a valid project
/// that is supported by this .
///
/// XML fragment representing the project file.
///
/// The XML fragment is not supported by this .
/// -or-
/// The XML fragment does not represent a valid project (for this ).
///
protected override void VerifyProjectXml(XmlElement docElement) {
if (!IsSupported(docElement)) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Project '{0}' is not a valid VB.NET project.", ProjectPath),
Location.UnknownLocation);
}
}
///
/// Returns the Visual Studio product version of the specified project
/// XML fragment.
///
/// The document element of the project.
///
/// The Visual Studio product version of the specified project XML
/// fragment.
///
///
/// The product version could not be determined.
/// -or-
/// The product version is not supported.
///
///
/// This method is called from the ctor, and
/// at that time we're not sure the XML that is passed in, is indeed a
/// valid Visual Basic project.
///
protected override ProductVersion DetermineProductVersion(XmlElement docElement) {
if (docElement == null) {
throw new ArgumentNullException("docElement");
}
return GetProductVersion(docElement.SelectSingleNode("./VisualBasic"));
}
#endregion Override implementation of ProjectBase
#region Override implemenation of ManagedProjectBase
///
/// Gets the default file extension of sources for this project.
///
///
/// For VB projects, the default file extension is ".vb".
///
protected override string FileExtension {
get { return ".vb"; }
}
///
/// Returns the project location from the specified project XML fragment.
///
/// XML fragment representing the project file.
///
/// The project location of the specified project XML file.
///
///
/// The project location could not be determined.
/// -or-
/// The project location is invalid.
///
protected override ProjectLocation DetermineProjectLocation(XmlElement docElement) {
return GetProjectLocation(docElement.SelectSingleNode("./VisualBasic"));
}
///
/// Returns a for launching the compiler
/// for this project.
///
/// The configuration to build.
/// The response file for the compiler.
///
/// A for launching the compiler for
/// this project.
///
protected override ProcessStartInfo GetProcessStartInfo(ConfigurationBase config, string responseFile) {
ProcessStartInfo psi = new ProcessStartInfo(FileUtils.CombinePaths(SolutionTask.
Project.TargetFramework.FrameworkDirectory.FullName, "vbc.exe"),
"@\"" + responseFile + "\"");
// Visual Basic.NET uses the directory from which VS.NET
// was launched as working directory, the closest match
// and best behaviour for us is to use the
// as working directory and fallback to the
// if the project was explicitly specified
if (SolutionTask.SolutionFile != null) {
psi.WorkingDirectory = SolutionTask.SolutionFile.DirectoryName;
} else {
psi.WorkingDirectory = ProjectDirectory.FullName;
}
return psi;
}
#endregion Override implemenation of ManagedProjectBase
#region Public Static Methods
///
/// Returns a value indicating whether the project represented by the
/// specified XML fragment is supported by .
///
/// XML fragment representing the project to check.
///
/// if supports the
/// specified project; otherwise, .
///
///
///
/// A project is identified as as Visual Basic project, if the XML
/// fragment at least has the following information:
///
///
///
///
/// ...
///
///
/// ]]>
///
///
public static bool IsSupported(XmlElement docElement) {
if (docElement == null) {
return false;
}
if (docElement.Name != "VisualStudioProject") {
return false;
}
XmlNode projectNode = docElement.SelectSingleNode("./VisualBasic");
if (projectNode == null) {
return false;
}
try {
GetProductVersion(projectNode);
// no need to perform version check here as this is done in
// GetProductVersion
} catch {
// product version could not be determined or is not supported
return false;
}
return true;
}
#endregion Public Static Methods
#region Private Instance Fields
private readonly NamespaceImportCollection _imports;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/ProjectSettings.cs 0000644 0001750 0001750 00000034100 11757302274 021132 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
namespace NAnt.VSNet {
public class ProjectSettings {
#region Public Instance Constructors
public ProjectSettings(XmlElement elemRoot, XmlElement elemSettings, ManagedProjectBase project) {
_project = project;
_settings = new ArrayList();
// check whether build file is valid
if (elemRoot.FirstChild == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Project file '{0}' is not valid.", Project.ProjectPath),
Location.UnknownLocation);
}
_guid = ProjectSettings.GetProjectGuid(project.ProjectPath,
elemRoot);
// determine output type of this project
_outputType = GetOutputType(elemSettings);
// initialize hashtable for holding string settings
Hashtable htStringSettings = new Hashtable();
switch (_outputType) {
case ManagedOutputType.Library:
_settings.Add("/target:library");
break;
case ManagedOutputType.Executable:
_settings.Add("/target:exe");
// startup object only makes sense for executable assemblies
htStringSettings["StartupObject"] = @"/main:""{0}""";
break;
case ManagedOutputType.WindowsExecutable:
_settings.Add("/target:winexe");
// startup object only makes sense for executable assemblies
htStringSettings["StartupObject"] = @"/main:""{0}""";
break;
}
// suppresses display of Microsoft startup banner
_settings.Add("/nologo");
_assemblyName = elemSettings.Attributes["AssemblyName"].Value;
// the key file to use to sign ActiveX/COM wrappers
_assemblyOriginatorKeyFile = StringUtils.ConvertEmptyToNull(
elemSettings.Attributes["AssemblyOriginatorKeyFile"].Value);
// the key container to use to sign ActiveX/COM wrappers
_assemblyKeyContainerName = StringUtils.ConvertEmptyToNull(
elemSettings.Attributes["AssemblyKeyContainerName"].Value);
// pre and post build events are VS .NET 2003 specific, so do not
// assume they are there
if (elemSettings.Attributes["RunPostBuildEvent"] != null) {
_runPostBuildEvent = StringUtils.ConvertEmptyToNull(
elemSettings.Attributes["RunPostBuildEvent"].Value);
}
if (elemSettings.Attributes["PreBuildEvent"] != null) {
_preBuildEvent = StringUtils.ConvertEmptyToNull(
elemSettings.Attributes["PreBuildEvent"].Value);
}
if (elemSettings.Attributes["PostBuildEvent"] != null) {
_postBuildEvent = StringUtils.ConvertEmptyToNull(
elemSettings.Attributes["PostBuildEvent"].Value);
}
if (elemSettings.Attributes["RootNamespace"] != null) {
_rootNamespace = StringUtils.ConvertEmptyToNull(
elemSettings.Attributes["RootNamespace"].Value);
if (RootNamespace != null && Project.Type == ProjectType.VB) {
_settings.Add("/rootnamespace:" + _rootNamespace);
}
}
if (elemSettings.Attributes["ApplicationIcon"] != null) {
string value = StringUtils.ConvertEmptyToNull(
elemSettings.Attributes["ApplicationIcon"].Value);
if (value != null) {
_applicationIcon = new FileInfo(FileUtils.CombinePaths(
Project.ProjectDirectory.FullName, value));
}
}
// process VB.NET specific project settings
if (Project.Type == ProjectType.VB) {
if (elemSettings.Attributes["OptionExplicit"] != null) {
if (elemSettings.Attributes ["OptionExplicit"].Value == "Off") {
_settings.Add("/optionexplicit-");
} else {
_settings.Add("/optionexplicit+");
}
}
if (elemSettings.Attributes["OptionStrict"] != null) {
if (elemSettings.Attributes ["OptionStrict"].Value == "Off") {
_settings.Add("/optionstrict-");
} else {
_settings.Add("/optionstrict+");
}
}
if (elemSettings.Attributes["OptionCompare"] != null) {
if (elemSettings.Attributes ["OptionCompare"].Value == "Text") {
_settings.Add("/optioncompare:text");
} else {
_settings.Add("/optioncompare:binary");
}
}
}
foreach (DictionaryEntry de in htStringSettings) {
string value = elemSettings.GetAttribute(de.Key.ToString());
if (String.IsNullOrEmpty(value)) {
// skip empty values
continue;
}
_settings.Add(string.Format(de.Value.ToString(), value));
}
}
#endregion Public Instance Constructors
#region Public Instance Properties
public string[] Settings {
get { return (string[]) _settings.ToArray(typeof(string)); }
}
///
/// Gets the .ico file to use as application icon.
///
///
/// The .ico file to use as application icon, or
/// if no application icon should be used.
///
public FileInfo ApplicationIcon {
get { return _applicationIcon; }
}
public string AssemblyName {
get { return _assemblyName; }
}
///
/// Gets the key file to use to sign ActiveX/COM wrappers.
///
///
/// The path of the key file to use to sign ActiveX/COM wrappers,
/// relative to the project root directory, or
/// if the wrapper assembly should not be signed using a key file.
///
public string AssemblyOriginatorKeyFile {
get { return _assemblyOriginatorKeyFile; }
}
///
/// Gets the key name to use to sign ActiveX/COM wrappers.
///
///
/// The name of the key container to use to sign ActiveX/COM wrappers,
/// or if the wrapper assembly should not be
/// signed using a key container.
///
public string AssemblyKeyContainerName {
get { return _assemblyKeyContainerName; }
}
public TempFileCollection TemporaryFiles {
get { return Project.TemporaryFiles; }
}
public string OutputFileName {
get { return string.Concat(AssemblyName, OutputExtension); }
}
///
/// Gets the output type of this project.
///
public ManagedOutputType OutputType {
get { return _outputType; }
}
public string OutputExtension {
get {
switch (OutputType) {
case ManagedOutputType.Library:
return ".dll";
case ManagedOutputType.Executable:
case ManagedOutputType.WindowsExecutable:
default:
return ".exe";
}
}
}
public string RootNamespace {
get { return _rootNamespace; }
}
public string Guid {
get { return _guid; }
}
///
/// Designates when the command line should
/// be run. Possible values are "OnBuildSuccess", "Always" or
/// "OnOutputUpdated".
///
public string RunPostBuildEvent {
get { return _runPostBuildEvent; }
}
///
/// Contains commands to be run before a build takes place.
///
///
/// Valid commands are those in a .bat file. For more info see MSDN.
///
public string PreBuildEvent {
get { return _preBuildEvent; }
}
///
/// Contains commands to be ran after a build has taken place.
///
///
/// Valid commands are those in a .bat file. For more info see MSDN.
///
public string PostBuildEvent {
get { return _postBuildEvent; }
}
#endregion Public Instance Properties
#region Private Instance Properties
private ManagedProjectBase Project {
get { return _project; }
}
#endregion Private Instance Properties
#region Protected Instance Methods
///
/// Determines the output type of the project from its XML definition.
///
/// The XML definition of the project settings.
///
/// The output type of the project.
///
///
///
/// The output type of the project is not set in the specified XML
/// definition.
///
/// -or-
///
/// The output type of the project is not supported.
///
///
protected virtual ManagedOutputType GetOutputType(XmlElement settingsXml) {
XmlAttribute outputTypeAttribute = settingsXml.Attributes["OutputType"];
if (outputTypeAttribute == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Project \"{0}\" is invalid: the output type is not set.",
Project.Name), Location.UnknownLocation);
}
switch (outputTypeAttribute.Value.ToLower(CultureInfo.InvariantCulture)) {
case "library":
return ManagedOutputType.Library;
case "exe":
return ManagedOutputType.Executable;
case "winexe":
return ManagedOutputType.WindowsExecutable;
default:
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Output type \"{0}\" of project \"{1}\" is not supported.",
outputTypeAttribute.Value, Project.Name), Location.UnknownLocation);
}
}
#endregion Protected Instance Methods
#region Public Static Methods
///
/// Gets the project GUID from the given
/// holding a <VisualStudioProject> node.
///
/// The path of the project file.
/// The <VisualStudioProject> node from which the project GUID should be retrieved.
///
/// The project GUID from specified <VisualStudioProject> node.
///
public static string GetProjectGuid(string projectFile, XmlElement elemRoot) {
XmlAttribute projectGuid = (XmlAttribute) elemRoot.FirstChild.
Attributes["ProjectGuid"];
if (projectGuid == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Project file '{0}' is not valid. There's no \"ProjectGuid\""
+ " attribute on the <{1} ... /> node.", projectFile,
elemRoot.FirstChild.Name), Location.UnknownLocation);
}
return projectGuid.Value.ToUpper(CultureInfo.InvariantCulture);
}
#endregion Public Static Methods
#region Public Instance Methods
public string GetTemporaryFilename(string fileName) {
return FileUtils.CombinePaths(TemporaryFiles.BasePath, fileName);
}
#endregion Public Instance Methods
#region Private Instance Fields
private readonly ArrayList _settings;
private readonly FileInfo _applicationIcon;
private readonly ManagedProjectBase _project;
private readonly string _assemblyName;
private readonly string _assemblyOriginatorKeyFile;
private readonly string _assemblyKeyContainerName;
private readonly string _rootNamespace;
private readonly string _guid;
private readonly string _runPostBuildEvent;
private readonly string _preBuildEvent;
private readonly string _postBuildEvent;
private readonly ManagedOutputType _outputType;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/WebDavClient.cs 0000644 0001750 0001750 00000012035 11757302274 020315 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
using System;
using System.IO;
using System.Net;
namespace NAnt.VSNet {
public class WebDavClient {
#region Public Instance Constructors
public WebDavClient(Uri uriBase) {
_webProjectBaseUrl = uriBase.ToString();
}
#endregion Public Instance Constructors
#region Public Instance Methods
public void UploadFile(string localFileName, string remoteFileName) {
WebRequest request = WebRequest.Create(_webProjectBaseUrl + "/" + remoteFileName);
request.Method = "PUT";
request.Headers.Add("Translate: f");
request.Credentials = CredentialCache.DefaultCredentials;
FileInfo fi = new FileInfo(localFileName);
request.ContentLength = fi.Length;
int bufferSize = 100 * 1024;
byte[] buffer = new byte[bufferSize];
using (FileStream fsInput = new FileStream(fi.FullName, FileMode.Open)) {
using (Stream s = request.GetRequestStream()) {
int nRead;
do {
nRead = fsInput.Read(buffer, 0, bufferSize);
s.Write(buffer, 0, nRead);
}
while (nRead > 0);
}
}
buffer = null;
try {
using (request.GetResponse()) {
}
} catch (WebException we) {
HttpWebResponse hwr = ( HttpWebResponse )we.Response;
if ((int) hwr.StatusCode != 423) {
throw;
}
}
}
public void DeleteFile(string localFileName, string remoteFileName) {
WebRequest request = WebRequest.Create(_webProjectBaseUrl + "/" + remoteFileName);
request.Method = "DELETE";
request.Headers.Add("Translate: f");
request.Credentials = CredentialCache.DefaultCredentials;
using (request.GetResponse()) {
}
}
public void DownloadFile(string localFileName, string remoteFileName) {
WebRequest request = WebRequest.Create(_webProjectBaseUrl + "/" + remoteFileName);
request.Method = "GET";
request.Headers.Add("Translate: f");
request.Credentials = CredentialCache.DefaultCredentials;
FileInfo fi = new FileInfo(localFileName);
if (!Directory.Exists(fi.DirectoryName)) {
Directory.CreateDirectory(fi.DirectoryName);
}
int bufferSize = 100 * 1024;
byte[] buffer = new byte[bufferSize];
using (FileStream fsOutput = new FileStream(fi.FullName, FileMode.OpenOrCreate)) {
using (Stream s = request.GetResponse().GetResponseStream()) {
int nRead;
do {
nRead = s.Read(buffer, 0, bufferSize);
fsOutput.Write(buffer, 0, nRead);
} while (nRead > 0);
}
}
buffer = null;
}
public string GetFileContents(string remoteFileName) {
WebRequest request = WebRequest.Create(_webProjectBaseUrl + "/" + remoteFileName);
request.Method = "GET";
request.Headers.Add("Translate: f");
request.Credentials = CredentialCache.DefaultCredentials;
using (StreamReader sr = new StreamReader(request.GetResponse().GetResponseStream())) {
return sr.ReadToEnd();
}
}
#endregion Public Instance Methods
#region Public Static Methods
public static string GetFileContentsStatic(string remoteFileName) {
WebRequest request = WebRequest.Create(remoteFileName);
request.Method = "GET";
request.Headers.Add("Translate: f");
request.Credentials = CredentialCache.DefaultCredentials;
using (StreamReader sr = new StreamReader(request.GetResponse().GetResponseStream())) {
return sr.ReadToEnd();
}
}
#endregion Public Static Methods
#region Private Instance Fields
private string _webProjectBaseUrl;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/ManagedProjectReference.cs 0000644 0001750 0001750 00000007370 11757302274 022516 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
namespace NAnt.VSNet {
public class ManagedProjectReference : ProjectReferenceBase {
public ManagedProjectReference(XmlElement xmlDefinition, ReferencesResolver referencesResolver, ProjectBase parent, SolutionBase solution, TempFileCollection tfc, GacCache gacCache, DirectoryInfo outputDir) : base(referencesResolver, parent) {
if (xmlDefinition == null) {
throw new ArgumentNullException("xmlDefinition");
}
if (solution == null) {
throw new ArgumentNullException("solution");
}
if (tfc == null) {
throw new ArgumentNullException("tfc");
}
if (gacCache == null) {
throw new ArgumentNullException("gacCache");
}
XmlAttribute privateAttribute = xmlDefinition.Attributes["Private"];
if (privateAttribute != null) {
_isPrivateSpecified = true;
_isPrivate = bool.Parse(privateAttribute.Value);
}
// determine path of project file
string projectFile = solution.GetProjectFileFromGuid(
xmlDefinition.GetAttribute("Project"));
// load referenced project
_project = LoadProject(solution, tfc, gacCache, outputDir, projectFile);
}
public ManagedProjectReference(ProjectBase project, ProjectBase parent, bool isPrivateSpecified, bool isPrivate) : base(project.ReferencesResolver, parent) {
_project = project;
_isPrivateSpecified = isPrivateSpecified;
_isPrivate = isPrivate;
}
#region Override implementation of ProjectReferenceBase
public override ProjectBase Project {
get { return _project; }
}
protected override bool IsPrivate {
get { return _isPrivate; }
}
protected override bool IsPrivateSpecified {
get { return _isPrivateSpecified; }
}
#endregion Override implementation of ProjectReferenceBase
#region Override implementation of ReferenceBase
///
/// Gets a value indicating whether the reference is managed for the
/// specified configuration.
///
/// The solution configuration that is built.
///
/// .
///
public override bool IsManaged(Configuration solutionConfiguration) {
return true;
}
#endregion Override implementation of ReferenceBase
#region Private Instance Fields
private readonly ProjectBase _project;
private readonly bool _isPrivateSpecified;
private readonly bool _isPrivate;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/Types/ 0000755 0001750 0001750 00000000000 11757310030 016547 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.VSNet/Types/UseOfMFC.cs 0000644 0001750 0001750 00000002422 11757302274 020460 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Hani Atassi (haniatassi@users.sourceforge.net)
namespace NAnt.VSNet.Types {
///
/// Defines how the project is using the MFC library.
///
public enum UseOfMFC {
///
/// Don't use MFC.
///
NotUsing = 0,
///
/// Use MFC in a Static Library.
///
Static = 1,
///
/// Use MFC in a Shared DLL.
///
Shared = 2
}
}
nant-0.92-rc1/src/NAnt.VSNet/Types/WebMap.cs 0000644 0001750 0001750 00000007550 11757302274 020273 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Tom Cabanski (tcabanski@OAI.cc)
using System;
using System.Collections.Specialized;
using System.IO;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Types;
using NAnt.Core.Util;
namespace NAnt.VSNet.Types {
///
/// Represents a single mapping from URL project path to physical project
/// path.
///
[Serializable()]
public class WebMap : Element {
#region Private Instance Fields
private string _url;
private FileInfo _path;
private bool _caseSensitive;
private bool _ifDefined = true;
private bool _unlessDefined;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Specifies the URL of the project file, or a URL fragment to match.
///
///
/// The URL of the project file or the URL fragment to match.
///
[TaskAttribute("url", Required=true)]
[StringValidator(AllowEmpty=false)]
public string Url {
get { return _url; }
set { _url = StringUtils.ConvertEmptyToNull(value); }
}
///
/// Specifies the actual path to the project file, or the path fragment
/// to replace.
///
///
/// The actual path to the project file or the path fragment to replace
/// the URL fragment with.
///
[TaskAttribute("path", Required=true)]
public FileInfo Path {
get { return _path; }
set { _path = value; }
}
///
/// Specifies whether the mapping is case-sensitive or not.
///
///
/// A boolean flag representing the case-sensitivity of the mapping. Default is .
///
[TaskAttribute("casesensitive", Required=false)]
[BooleanValidator()]
public bool CaseSensitive {
get { return _caseSensitive; }
set { _caseSensitive = value; }
}
///
/// Indicates if the URL of the project file should be mapped.
///
///
/// if the URL of the project file should be
/// mapped; otherwise, .
///
[TaskAttribute("if")]
[BooleanValidator()]
public bool IfDefined {
get { return _ifDefined; }
set { _ifDefined = value; }
}
///
/// Indicates if the URL of the project file should not be mapped.
///
///
/// if the URL of the project file should not
/// be mapped; otherwise, .
///
[TaskAttribute("unless")]
[BooleanValidator()]
public bool UnlessDefined {
get { return _unlessDefined; }
set { _unlessDefined = value; }
}
#endregion Public Instance Properties
}
}
nant-0.92-rc1/src/NAnt.VSNet/Types/WebMapCollection.cs 0000644 0001750 0001750 00000026103 11757302274 022302 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
using System.Globalization;
namespace NAnt.VSNet.Types {
///
/// Contains a strongly typed collection of
/// objects.
///
[Serializable()]
public class WebMapCollection : CollectionBase {
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public WebMapCollection() {
}
///
/// Initializes a new instance of the class
/// with the specified instance.
///
public WebMapCollection(WebMapCollection value) {
AddRange(value);
}
///
/// Initializes a new instance of the class
/// with the specified array of instances.
///
public WebMapCollection(WebMap[] value) {
AddRange(value);
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets or sets the element at the specified index.
///
/// The zero-based index of the element to get or set.
[System.Runtime.CompilerServices.IndexerName("Item")]
public WebMap this[int index] {
get { return ((WebMap)(base.List[index])); }
set { base.List[index] = value; }
}
///
/// Gets the with the specified value.
///
/// The value of the to get.
[System.Runtime.CompilerServices.IndexerName("Item")]
public WebMap this[string value] {
get {
if (value != null) {
// Try to locate instance using Value
foreach (WebMap WebMap in base.List) {
if (string.Compare(WebMap.Url, value, !WebMap.CaseSensitive, CultureInfo.InvariantCulture) == 0) {
return WebMap;
}
}
}
return null;
}
}
///
/// Find the best matching for the given Uri.
///
/// The value to match against the objects in the collection.
public string FindBestMatch(string uri)
{
string bestMatch = null;
int bestMatchLength = Int32.MinValue;
foreach (WebMap webMap in base.List) {
if (!webMap.IfDefined || webMap.UnlessDefined)
continue;
string testSubject = webMap.CaseSensitive ? uri : uri.ToUpper(CultureInfo.InvariantCulture);
string testTarget = webMap.CaseSensitive ? webMap.Url : webMap.Url.ToUpper(CultureInfo.InvariantCulture);
if (testSubject.StartsWith(testTarget) && testTarget.Length > bestMatchLength) {
bestMatchLength = testTarget.Length;
bestMatch = webMap.Path.FullName + uri.Substring(testTarget.Length);
}
}
return bestMatch;
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Adds a to the end of the collection.
///
/// The to be added to the end of the collection.
/// The position into which the new element was inserted.
public int Add(WebMap item) {
return base.List.Add(item);
}
///
/// Adds the elements of a array to the end of the collection.
///
/// The array of elements to be added to the end of the collection.
public void AddRange(WebMap[] items) {
for (int i = 0; (i < items.Length); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Adds the elements of a to the end of the collection.
///
/// The to be added to the end of the collection.
public void AddRange(WebMapCollection items) {
for (int i = 0; (i < items.Count); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Determines whether a is in the collection.
///
/// The to locate in the collection.
///
/// if is found in the
/// collection; otherwise, .
///
public bool Contains(WebMap item) {
return base.List.Contains(item);
}
///
/// Determines whether a with the specified
/// value is in the collection.
///
/// The argument value to locate in the collection.
///
/// if a with value
/// is found in the collection; otherwise,
/// .
///
public bool Contains(string value) {
return this[value] != null;
}
///
/// Copies the entire collection to a compatible one-dimensional array, starting at the specified index of the target array.
///
/// The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.
/// The zero-based index in at which copying begins.
public void CopyTo(WebMap[] array, int index) {
base.List.CopyTo(array, index);
}
///
/// Retrieves the index of a specified object in the collection.
///
/// The object for which the index is returned.
///
/// The index of the specified . If the is not currently a member of the collection, it returns -1.
///
public int IndexOf(WebMap item) {
return base.List.IndexOf(item);
}
///
/// Inserts a into the collection at the specified index.
///
/// The zero-based index at which should be inserted.
/// The to insert.
public void Insert(int index, WebMap item) {
base.List.Insert(index, item);
}
///
/// Returns an enumerator that can iterate through the collection.
///
///
/// A for the entire collection.
///
public new WebMapEnumerator GetEnumerator() {
return new WebMapEnumerator(this);
}
///
/// Removes a member from the collection.
///
/// The to remove from the collection.
public void Remove(WebMap item) {
base.List.Remove(item);
}
#endregion Public Instance Methods
}
///
/// Enumerates the elements of a .
///
public class WebMapEnumerator : IEnumerator {
#region Internal Instance Constructors
///
/// Initializes a new instance of the class
/// with the specified .
///
/// The collection that should be enumerated.
internal WebMapEnumerator(WebMapCollection arguments) {
IEnumerable temp = (IEnumerable) (arguments);
_baseEnumerator = temp.GetEnumerator();
}
#endregion Internal Instance Constructors
#region Implementation of IEnumerator
///
/// Gets the current element in the collection.
///
///
/// The current element in the collection.
///
public WebMap Current {
get { return (WebMap) _baseEnumerator.Current; }
}
object IEnumerator.Current {
get { return _baseEnumerator.Current; }
}
///
/// Advances the enumerator to the next element of the collection.
///
///
/// if the enumerator was successfully advanced
/// to the next element; if the enumerator has
/// passed the end of the collection.
///
public bool MoveNext() {
return _baseEnumerator.MoveNext();
}
bool IEnumerator.MoveNext() {
return _baseEnumerator.MoveNext();
}
///
/// Sets the enumerator to its initial position, which is before the
/// first element in the collection.
///
public void Reset() {
_baseEnumerator.Reset();
}
void IEnumerator.Reset() {
_baseEnumerator.Reset();
}
#endregion Implementation of IEnumerator
#region Private Instance Fields
private IEnumerator _baseEnumerator;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/Types/UseOfATL.cs 0000644 0001750 0001750 00000002422 11757302274 020473 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Hani Atassi (haniatassi@users.sourceforge.net)
namespace NAnt.VSNet.Types {
///
/// Defines how the project is using the ATL library.
///
public enum UseOfATL {
///
/// Don't use ATL.
///
NotUsing = 0,
///
/// Use ATL in a Static Library.
///
Static = 1,
///
/// Use ATL in a Shared DLL.
///
Shared = 2
}
}
nant-0.92-rc1/src/NAnt.VSNet/Types/UsePrecompiledHeader.cs 0000644 0001750 0001750 00000004737 11757302274 023155 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Simon Keary (simonkeary@post.com)
namespace NAnt.VSNet.Types {
///
/// Indicates the possible ways in which precompiled header file use is
/// specified in a Visual C++ project.
///
///
/// The integer values assigned match those specified in the Visual C++
/// project file for each setting.
/// >
public enum UsePrecompiledHeader {
///
/// Precompiled header file use not specified.
///
Unspecified = -1,
///
/// Don't use a precompiled header file.
///
///
/// For further information on the use of this option
/// see the Microsoft documentation on the C++ compiler flag /Yc.
///
No = 0,
///
/// Create precompiled header file.
///
///
/// For further information on the use of this option
/// see the Microsoft documentation on the C++ compiler flag /Yc.
///
Create = 1,
///
/// Automatically create precompiled header file if necessary.
///
///
/// For further information on the use of this option
/// see the Microsoft documentation on the C++ compiler flag /Yc.
///
AutoCreate = 2,
///
/// Use a precompiled header file.
///
///
/// For further information on the use of this option
/// see the Microsoft documentation on the C++ compiler flag /Yu.
///
Use = 3
}
}
nant-0.92-rc1/src/NAnt.VSNet/ManagedWrapperReference.cs 0000644 0001750 0001750 00000034140 11757302274 022523 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
// Scott Ford (sford@RJKTECH.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Globalization;
using System.IO;
using System.Xml;
using Microsoft.Win32;
using NAnt.Core;
using NAnt.Core.Tasks;
using NAnt.Core.Util;
using NAnt.Core.Types;
using NAnt.Win32.Tasks;
namespace NAnt.VSNet {
public class ManagedWrapperReference : WrapperReferenceBase {
#region Public Instance Constructors
public ManagedWrapperReference(XmlElement xmlDefinition, ReferencesResolver referencesResolver, ProjectBase parent, GacCache gacCache, ProjectSettings projectSettings) : base(xmlDefinition, referencesResolver, parent, gacCache) {
if (projectSettings == null) {
throw new ArgumentNullException("projectSettings");
}
_projectSettings = projectSettings;
// determine name of wrapper reference
XmlAttribute wrapperNameAttribute = XmlDefinition.Attributes["Name"];
if (wrapperNameAttribute != null) {
_name = wrapperNameAttribute.Value;
}
// determine wrapper tool
XmlAttribute toolAttribute = XmlDefinition.Attributes["WrapperTool"];
if (toolAttribute == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Wrapper tool for reference \"{0}\" in project \"{1}\" could"
+ " not be determined.", Name, Parent.Name),
Location.UnknownLocation);
}
_wrapperTool = toolAttribute.Value;
// determine if there's a primary interop assembly for the typelib
_primaryInteropAssembly = GetPrimaryInteropAssembly();
// determine filename of wrapper assembly
_wrapperAssembly = ResolveWrapperAssembly();
}
#endregion Public Instance Constructors
#region Override implementation of ReferenceBase
///
/// Gets the name of the referenced assembly.
///
///
/// The name of the referenced assembly, or if
/// the name could not be determined.
///
public override string Name {
get { return _name; }
}
#endregion Override implementation of ReferenceBase
#region Override implementation of WrapperReferenceBase
///
/// Gets the name of the tool that should be used to create the
/// .
///
///
/// The name of the tool that should be used to create the
/// .
///
public override string WrapperTool {
get { return _wrapperTool; }
}
///
/// Gets the path of the wrapper assembly.
///
///
/// The path of the wrapper assembly.
///
///
/// The wrapper assembly is stored in the object directory of the
/// project.
///
public override string WrapperAssembly {
get { return _wrapperAssembly; }
}
///
/// Gets the path of the Primary Interop Assembly.
///
///
/// The path of the Primary Interop Assembly, or
/// if not available.
///
protected override string PrimaryInteropAssembly {
get { return _primaryInteropAssembly; }
}
///
/// Gets the hex version of the type library as defined in the definition
/// of the reference.
///
///
/// The hex version of the type library.
///
///
///
/// The definition of the reference does not contain a "VersionMajor" attribute.
///
/// -or
///
/// The definition of the reference does not contain a "VersionMinor" attribute.
///
///
protected override string TypeLibVersion {
get {
XmlAttribute majorAttribute = XmlDefinition.Attributes["VersionMajor"];
if (majorAttribute == null) {
throw new BuildException("The definition of the reference"
+ " does not contain a \"VersionMajor\" attribute.");
}
XmlAttribute minorAttribute = XmlDefinition.Attributes["VersionMinor"];
if (minorAttribute == null) {
throw new BuildException("The definition of the reference"
+ " does not contain a \"VersionMinor\" attribute.");
}
string majorVersion = (int.Parse(majorAttribute.Value,
CultureInfo.InvariantCulture)).ToString("x",
CultureInfo.InvariantCulture);
string minorVersion = (int.Parse(minorAttribute.Value,
CultureInfo.InvariantCulture)).ToString("x",
CultureInfo.InvariantCulture);
return majorVersion + "." + minorVersion;
}
}
///
/// Gets the GUID of the type library as defined in the definition
/// of the reference.
///
///
/// The GUID of the type library.
///
protected override string TypeLibGuid {
get {
XmlAttribute guidAttribute = XmlDefinition.Attributes["Guid"];
if (guidAttribute == null) {
throw new BuildException("The definition of the reference"
+ " does not contain a \"Guid\" attribute.");
}
return guidAttribute.Value;
}
}
///
/// Gets the locale of the type library in hex notation.
///
///
/// The locale of the type library.
///
protected override string TypeLibLocale {
get {
XmlAttribute localeAttribute = XmlDefinition.Attributes["Lcid"];
if (localeAttribute == null) {
throw new BuildException("The definition of the reference"
+ " does not contain a \"Lcid\" attribute.");
}
return int.Parse(localeAttribute.Value).ToString("x");
}
}
#endregion Override implementation of WrapperReferenceBase
#region Private Instance Properties
private ProjectSettings ProjectSettings {
get { return _projectSettings; }
}
#endregion Private Instance Properties
#region Private Instance Methods
protected override void ImportTypeLibrary() {
TlbImpTask tlbImp = new TlbImpTask();
// parent is solution task
tlbImp.Parent = SolutionTask;
// inherit project from solution task
tlbImp.Project = SolutionTask.Project;
// inherit namespace manager from solution task
tlbImp.NamespaceManager = SolutionTask.NamespaceManager;
// inherit verbose setting from solution task
tlbImp.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
tlbImp.InitializeTaskConfiguration();
tlbImp.TypeLib = new FileInfo(GetTypeLibrary());
tlbImp.OutputFile = new FileInfo(WrapperAssembly);
tlbImp.Namespace = TypeLibraryName;
// according to "COM Programming with Microsoft .NET" (page 59)
// the /sysarray option should always be set in order to
// generate wrappers that match those generated by VS.NET
tlbImp.SysArray = true;
// transform [out, retval] parameters of methods on dispatch-only
// interfaces (dispinterfaces) into return values.
//
// this only affects .NET 1.1 or higher, as tlbimp does not expose
// this on .NET 1.0.
tlbImp.Transform = "dispret";
// use other imported type libraries to resolve references
//
// there's one serious limitation in the current implementation:
//
// if type library A references type library B, then we should
// first import type library B and use a reference to that
// imported type library when we import type library A.
//
// however, we have no way to find out in which order the type
// libraries should be imported. So only if type library B is
// first listed in the project file, it will work fine.
//
// we should find a way to analyse a type library to determine
// dependencies on other type libraries
//
// according to JR (jrv72@users.sourceforge.net) a possible
// solution could be to "use TypeLibConverter.ConvertTypeLibToAssembly.
// This has a callback of type ITypeLibImporterNotifySink, which I
// speculate allows one to recognize when one type library
// depends on another. I believe what you have to do is start
// with an arbitrary type library, and if that type library calls
// back on the ResolveRef() method, and if that type library is
// one you were planning to add later, you compile it
// immediately and pass the assembly back out of ResolveRef. I
// haven't tested this yet, but it's my best understanding of
// how it all works.
foreach (ReferenceBase reference in Parent.References) {
// we're only interested in imported type libraries
WrapperReferenceBase wrapper = reference as WrapperReferenceBase;
// avoid stack overflow causes by mutual dependencies
if (wrapper == null || !wrapper.IsCreated || wrapper.WrapperTool != "tlbimp") {
continue;
}
tlbImp.References.Includes.Add(wrapper.WrapperAssembly);
}
if (ProjectSettings.AssemblyOriginatorKeyFile != null) {
tlbImp.KeyFile = new FileInfo(FileUtils.CombinePaths(Parent.ProjectDirectory.FullName,
ProjectSettings.AssemblyOriginatorKeyFile));
}
if (ProjectSettings.AssemblyKeyContainerName != null) {
tlbImp.KeyContainer = ProjectSettings.AssemblyKeyContainerName;
}
// increment indentation level
tlbImp.Project.Indent();
try {
// execute task
tlbImp.Execute();
} finally {
// restore indentation level
tlbImp.Project.Unindent();
}
}
protected override void ImportActiveXLibrary() {
AxImpTask axImp = new AxImpTask();
// parent is solution task
axImp.Parent = SolutionTask;
// inherit project from solution task
axImp.Project = SolutionTask.Project;
// inherit namespace manager from solution task
axImp.NamespaceManager = SolutionTask.NamespaceManager;
// inherit verbose setting from solution task
axImp.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
axImp.InitializeTaskConfiguration();
axImp.OcxFile = new FileInfo(GetTypeLibrary());
axImp.OutputFile = new FileInfo(WrapperAssembly);
if (ProjectSettings.AssemblyOriginatorKeyFile != null) {
axImp.KeyFile = new FileInfo(FileUtils.CombinePaths(Parent.ProjectDirectory.FullName,
ProjectSettings.AssemblyOriginatorKeyFile));
}
if (ProjectSettings.AssemblyKeyContainerName != null) {
axImp.KeyContainer = ProjectSettings.AssemblyKeyContainerName;
}
string rcw = PrimaryInteropAssembly;
if (rcw == null) {
// if no primary interop assembly is provided for ActiveX control,
// then use the imported type library (if available)
rcw = FileUtils.CombinePaths(Parent.ObjectDir.FullName,
"Interop." + TypeLibraryName + ".dll");
}
if (File.Exists(rcw)) {
axImp.RcwFile = new FileInfo(rcw);
}
// increment indentation level
axImp.Project.Indent();
try {
// execute task
axImp.Execute();
} finally {
// restore indentation level
axImp.Project.Unindent();
}
}
#endregion Private Instance Methods
#region Private Instance Fields
private string _name;
private readonly string _wrapperTool;
private readonly string _wrapperAssembly;
private readonly ProjectSettings _projectSettings;
private string _primaryInteropAssembly;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/VcProjectConfiguration.cs 0000644 0001750 0001750 00000076756 11757302274 022461 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2005 Gert Driesen
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VisualCpp.Types;
using NAnt.VSNet.Types;
namespace NAnt.VSNet {
///
/// Represents a Visual C++ project configuration.
///
public class VcProjectConfiguration : VcConfigurationBase {
#region Internal Instance Constructors
internal VcProjectConfiguration(XmlElement elem, VcProject parentProject, DirectoryInfo outputDir) : base(elem, parentProject, outputDir) {
// determine relative output directory (outdir)
XmlAttribute outputDirAttribute = elem.Attributes["OutputDirectory"];
if (outputDirAttribute != null) {
_rawRelativeOutputDir = outputDirAttribute.Value;
}
// get intermediate directory and expand macros
XmlAttribute intermidiateDirAttribute = elem.Attributes["IntermediateDirectory"];
if (intermidiateDirAttribute != null) {
_rawIntermediateDir = intermidiateDirAttribute.Value;
}
// get referencespath directory and expand macros
XmlAttribute referencesPathAttribute = elem.Attributes["ReferencesPath"];
if (referencesPathAttribute != null) {
_rawReferencesPath = StringUtils.ConvertEmptyToNull(referencesPathAttribute.Value);
}
string managedExtentions = GetXmlAttributeValue(elem, "ManagedExtensions");
if (managedExtentions != null) {
switch(managedExtentions.ToLower()) {
case "false":
case "0":
_managedExtensions = false;
break;
case "true":
case "1":
_managedExtensions = true;
break;
default:
throw new BuildException(String.Format("ManagedExtensions '{0}' is not supported yet.",managedExtentions));
}
}
// get configuration type
string type = GetXmlAttributeValue(elem, "ConfigurationType");
if (type != null) {
_type = (ConfigurationType) Enum.ToObject(typeof(ConfigurationType),
int.Parse(type, CultureInfo.InvariantCulture));
}
string wholeProgramOptimization = GetXmlAttributeValue(elem, "WholeProgramOptimization");
if (wholeProgramOptimization != null) {
_wholeProgramOptimization = string.Compare(wholeProgramOptimization.Trim(), "true", true, CultureInfo.InvariantCulture) == 0;
}
string characterSet = GetXmlAttributeValue(elem, "CharacterSet");
if (characterSet != null) {
_characterSet = (CharacterSet) Enum.ToObject(typeof(CharacterSet),
int.Parse(characterSet, CultureInfo.InvariantCulture));
}
// get MFC settings
string useOfMFC = GetXmlAttributeValue(elem, "UseOfMFC");
if (useOfMFC != null) {
_useOfMFC = (UseOfMFC) Enum.ToObject(typeof(UseOfMFC),
int.Parse(useOfMFC, CultureInfo.InvariantCulture));
}
// get ATL settings
string useOfATL = GetXmlAttributeValue(elem, "UseOfATL");
if (useOfATL != null) {
_useOfATL = (UseOfATL) Enum.ToObject(typeof(UseOfATL),
int.Parse(useOfATL, CultureInfo.InvariantCulture));
}
_linkerConfiguration = new LinkerConfig(this);
}
#endregion Internal Instance Constructors
#region Public Instance Properties
public ConfigurationType Type {
get { return _type; }
}
public bool WholeProgramOptimization {
get { return _wholeProgramOptimization; }
}
///
/// Tells the compiler which character set to use.
///
public CharacterSet CharacterSet {
get { return _characterSet; }
}
///
/// Gets a value indicating whether Managed Extensions for C++ are
/// enabled.
///
public bool ManagedExtensions {
get { return _managedExtensions; }
}
///
/// Gets a value indicating how MFC is used by the configuration.
///
public UseOfMFC UseOfMFC {
get { return _useOfMFC; }
}
///
/// Gets a value indicating how ATL is used by the configuration.
///
public UseOfATL UseOfATL {
get { return _useOfATL; }
}
#endregion Public Instance Properties
#region Internal Instance Properties
internal string RawRelativeOutputDir {
get { return _rawRelativeOutputDir;}
}
internal string RawIntermediateDir {
get { return _rawIntermediateDir;}
}
internal string RawReferencesPath {
get { return _rawReferencesPath; }
}
internal LinkerConfig LinkerConfiguration {
get { return _linkerConfiguration; }
}
///
/// Gets the list of files to link in the order in which they are
/// defined in the project file.
///
internal ArrayList ObjFiles {
get {
// lazy init
if (!_initialized) {
Initialize();
}
return _objFiles;
}
}
///
/// Holds the C++ sources for each build configuration.
///
///
/// The key of the hashtable is a build configuration, and the
/// value is an ArrayList holding the C++ source files for that
/// build configuration.
///
internal Hashtable SourceConfigs {
get {
// lazy init
if (!_initialized) {
Initialize();
}
return _sourceConfigs;
}
}
///
/// Gets the resources for each build configuration.
///
///
/// The key of the hashtable is a build configuration, and the
/// value is an ArrayList holding the resources files for that
/// build configuration.
///
internal Hashtable RcConfigs {
get {
// lazy init
if (!_initialized) {
Initialize();
}
return _rcConfigs;
}
}
///
/// Get the IDL files for each build configuration.
///
///
/// The key of the hashtable is a build configuration, and the
/// value is an ArrayList holding the IDL files for that build
/// configuration.
///
internal Hashtable IdlConfigs {
get {
// lazy init
if (!_initialized) {
Initialize();
}
return _idlConfigs;
}
}
#endregion Internal Instance Properties
#region Private Instance Properties
///
/// Gets the target path for usage in macro expansion.
///
///
/// The target path, or a zero-length string if there's no output file
/// for this configuration.
///
private string TargetPath {
get {
string targetPath = string.Empty;
switch (Type) {
case ConfigurationType.Application:
string applicationOutput = GetToolSetting(VcConfigurationBase.LinkerTool, "OutputFile");
if (String.IsNullOrEmpty(applicationOutput)) {
applicationOutput = ExpandMacros("$(OutDir)/$(ProjectName).exe");
}
targetPath = FileUtils.CombinePaths(Project.ProjectDirectory.FullName, applicationOutput);
break;
case ConfigurationType.DynamicLibrary:
string libraryOutput = GetToolSetting(VcConfigurationBase.LinkerTool, "OutputFile");
if (String.IsNullOrEmpty(libraryOutput)) {
libraryOutput = ExpandMacros("$(OutDir)/$(ProjectName).dll");
}
targetPath = FileUtils.CombinePaths(Project.ProjectDirectory.FullName, libraryOutput);
break;
case ConfigurationType.StaticLibrary:
string librarianOutput = GetToolSetting(VcConfigurationBase.LibTool, "OutputFile");
if (String.IsNullOrEmpty(librarianOutput)) {
librarianOutput = ExpandMacros("$(OutDir)/$(ProjectName).lib");
}
targetPath = FileUtils.CombinePaths(Project.ProjectDirectory.FullName, librarianOutput);
break;
case ConfigurationType.Makefile:
string nmakeOutput = GetToolSetting(VcConfigurationBase.NMakeTool, "Output");
if (!String.IsNullOrEmpty(nmakeOutput)) {
targetPath = FileUtils.CombinePaths(Project.ProjectDirectory.FullName, nmakeOutput);
}
break;
case ConfigurationType.Utility:
break;
}
return targetPath;
}
}
#endregion Private Instance Properties
#region Override implementation of ConfigurationBase
///
/// Get the directory in which intermediate build output will be stored
/// for this configuration.
///
///
///
/// This is a directory relative to the project directory named
/// obj\<configuration name>.
///
///
/// .resx and .licx files will only be recompiled if the
/// compiled resource files in the are not
/// uptodate.
///
///
public override DirectoryInfo ObjectDir {
get {
return new DirectoryInfo(FileUtils.CombinePaths(Project.ProjectDirectory.FullName,
IntermediateDir));
}
}
///
/// Get the path of the output directory relative to the project
/// directory.
///
public override string RelativeOutputDir {
get { return ExpandMacros(RawRelativeOutputDir); }
}
#endregion Override implementation of ConfigurationBase
#region Override implementation of VcConfigurationBase
///
/// Gets the intermediate directory, specified relative to project
/// directory.
///
///
/// The intermediate directory, specified relative to project directory.
///
public override string IntermediateDir {
get { return ExpandMacros(RawIntermediateDir); }
}
///
/// Gets the absolute path for the output file.
///
///
/// The absolute path for the output file, or
/// if there's no output file for this configuration.
///
public override string OutputPath {
get {
// lazy init
if (!_initialized) {
Initialize();
}
return _outputPath;
}
}
///
/// Gets a comma-separated list of directories to scan for assembly
/// references.
///
///
/// A comma-separated list of directories to scan for assembly
/// references, or if no additional directories
/// should scanned.
///
public override string ReferencesPath {
get { return ExpandMacros(RawReferencesPath); }
}
internal string GetToolSetting(string toolName, string settingName, ExpansionHandler expander) {
return GetToolSetting(toolName, settingName, (string) null, expander);
}
public override string GetToolSetting(string toolName, string settingName, string defaultValue) {
return GetToolSetting(toolName, settingName, defaultValue,
new ExpansionHandler(ExpandMacros));
}
internal string GetToolSetting(string toolName, string settingName, string defaultValue, ExpansionHandler expander) {
string setting = null;
Hashtable toolSettings = (Hashtable) Tools[toolName];
if (toolSettings != null) {
setting = (string) toolSettings[settingName];
if (setting != null) {
// expand macros
return expander(setting);
}
}
if (setting == null && defaultValue != null) {
return expander(defaultValue);
}
return setting;
}
public override Hashtable GetToolArguments(string toolName, VcArgumentMap argMap, VcArgumentMap.ArgGroup ignoreGroup) {
return GetToolArguments(toolName, argMap, ignoreGroup, new ExpansionHandler(ExpandMacros));
}
internal Hashtable GetToolArguments(string toolName, VcArgumentMap argMap, VcArgumentMap.ArgGroup ignoreGroup, ExpansionHandler expander) {
Hashtable args = CollectionsUtil.CreateCaseInsensitiveHashtable();
Hashtable toolSettings = (Hashtable) Tools[toolName];
if (toolSettings != null) {
foreach (DictionaryEntry de in toolSettings) {
string arg = argMap.GetArgument((string) de.Key, expander((string) de.Value), ignoreGroup);
if (arg != null) {
args[(string) de.Key] = arg;
}
}
}
return args;
}
///
/// Expands the given macro.
///
/// The macro to expand.
///
/// The expanded macro.
///
///
/// The macro is not supported.
/// -or-
/// The macro is not implemented.
/// -or-
/// The macro cannot be expanded.
///
///
/// Expansion of a given macro is not yet implemented.
///
protected internal override string ExpandMacro(string macro) {
// perform case-insensitive expansion of macros
switch (macro.ToLower(CultureInfo.InvariantCulture)) {
case "targetname": // E.g. WindowsApplication1
return Path.GetFileNameWithoutExtension(Path.GetFileName(
TargetPath));
case "targetpath": // E.g. C:\Doc...\Visual Studio Projects\WindowsApplications1\bin\Debug\WindowsApplications1.exe
return TargetPath;
case "targetext": // E.g. .exe
return Path.GetExtension(TargetPath);
case "targetfilename": // E.g. WindowsApplications1.exe
return Path.GetFileName(TargetPath);
case "targetdir": // E.g. C:\Doc...\Visual Studio Projects\WindowsApplications1\bin\Debug
return Path.GetDirectoryName(TargetPath) + (TargetPath.EndsWith(
Path.DirectorySeparatorChar.ToString(CultureInfo.InvariantCulture))
? string.Empty : Path.DirectorySeparatorChar.ToString(CultureInfo.InvariantCulture));
default:
return base.ExpandMacro(macro);
}
}
#endregion Override implementation of VcConfigurationBase
#region Private Instance Methods
private void Initialize() {
VcProject vcProject = (VcProject) Project;
// determine directory for storing intermediate build output for
// current project build configuration
string intermediateDir = FileUtils.CombinePaths(vcProject.ProjectDirectory.FullName,
IntermediateDir);
foreach (object projectFile in vcProject.ProjectFiles) {
string fileName = null;
VcConfigurationBase fileConfig = null;
// the array list contains either strings or hashtables
if (projectFile is string) {
fileName = (string) projectFile;
} else {
Hashtable fileConfigurations = (Hashtable) projectFile;
// obtain file configuration for current build configuration
VcFileConfiguration configuration = (VcFileConfiguration)
fileConfigurations[Name];
if (configuration != null && configuration.ExcludeFromBuild) {
continue;
}
fileConfig = configuration;
// determine relative path
if (configuration == null) {
// obtain relative path for other build configuration
// as the relative is the same anyway
foreach (DictionaryEntry de in fileConfigurations) {
configuration = (VcFileConfiguration) de.Value;
break;
}
}
fileName = configuration.RelativePath;
}
string ext = Path.GetExtension(fileName).ToLower(CultureInfo.InvariantCulture);
// if there's no specific file configuration (for the current
// build configuration), then use the project configuration
if (fileConfig == null) {
fileConfig = this;
}
switch (ext) {
case ".cpp":
case ".c":
if (!_sourceConfigs.ContainsKey(fileConfig)) {
_sourceConfigs[fileConfig] = new ArrayList(1);
}
// add file to list of sources to build with this config
((ArrayList) _sourceConfigs[fileConfig]).Add(fileName);
// register output file for linking
_objFiles.Add(vcProject.GetObjOutputFile(fileName,
fileConfig, intermediateDir));
break;
case ".rc":
if (!_rcConfigs.ContainsKey(fileConfig)) {
_rcConfigs[fileConfig] = new ArrayList(1);
}
// add file to list of resources to build with this config
((ArrayList) _rcConfigs[fileConfig]).Add(fileName);
// register output file for linking
_objFiles.Add(vcProject.GetResourceOutputFile(fileName,
fileConfig));
break;
case ".idl":
case ".odl": // ODL is used for old OLE objects
if (!_idlConfigs.ContainsKey(fileConfig)) {
_idlConfigs[fileConfig] = new ArrayList(1);
}
// add file to list of idl's to build with this config
((ArrayList) _idlConfigs[fileConfig]).Add(fileName);
break;
}
}
switch (Type) {
case ConfigurationType.StaticLibrary:
_outputPath = GetLibrarianOutputFile(intermediateDir);
break;
case ConfigurationType.Application:
case ConfigurationType.DynamicLibrary:
_outputPath = GetLinkerOutputFile();
break;
case ConfigurationType.Makefile:
string nmakeOutput = GetToolSetting(VcConfigurationBase.NMakeTool, "Output");
if (!String.IsNullOrEmpty(nmakeOutput)) {
_outputPath = FileUtils.CombinePaths(Project.ProjectDirectory.FullName, nmakeOutput);
}
break;
}
// mark initialization complete
_initialized = true;
}
private string GetLibrarianOutputFile(string intermediateDir) {
if (_objFiles.Count == 0) {
return null;
}
string outFile = GetToolSetting(VcConfigurationBase.LibTool,
"OutputFile", "$(OutDir)/$(ProjectName).lib");
// if OutputFile is explicitly set to an empty string, VS.NET
// uses file name of first obj file (in intermediate directory)
if (String.IsNullOrEmpty(outFile)) {
outFile = FileUtils.CombinePaths(intermediateDir,
Path.GetFileNameWithoutExtension((string) _objFiles[0])
+ ".lib");
} else {
outFile = FileUtils.CombinePaths(Project.ProjectDirectory.FullName,
outFile);
}
return outFile;
}
private string GetLinkerOutputFile() {
const string noinherit = "$(noinherit)";
string addDeps = GetToolSetting(VcConfigurationBase.LinkerTool, "AdditionalDependencies");
if (!String.IsNullOrEmpty(addDeps)) {
// remove noherit macro from addDeps
if (addDeps.ToLower(CultureInfo.InvariantCulture).IndexOf(noinherit) != -1) {
addDeps = addDeps.Remove(addDeps.ToLower(CultureInfo.InvariantCulture).IndexOf(noinherit), noinherit.Length);
}
string[] depParts = addDeps.Split(' ');
for (int i = 0; i < depParts.Length; i++) {
string addDep = depParts[i];
if (Path.GetExtension(addDep) == ".obj") {
_objFiles.Insert(i, addDep);
}
}
}
if (_objFiles.Count == 0) {
return null;
}
string extension = string.Empty;
switch (Type) {
case ConfigurationType.Application:
extension = ".exe";
break;
case ConfigurationType.DynamicLibrary:
extension = ".dll";
break;
}
// output file name
string outFile = GetToolSetting(VcConfigurationBase.LinkerTool,
"OutputFile", "$(OutDir)/$(ProjectName)" + extension);
// if OutputFile is explicitly set to an empty string, VS.NET
// uses file name of first obj file (in the current directory) and
// extention based on configuration type
if (String.IsNullOrEmpty(outFile)) {
outFile = FileUtils.CombinePaths(Project.ProjectDirectory.FullName,
Path.GetFileNameWithoutExtension((string) _objFiles[0]) +
extension);
}
if (SolutionTask.OutputDir != null) {
outFile = FileUtils.CombinePaths(SolutionTask.OutputDir.FullName,
Path.GetFileName(outFile));
} else {
outFile = FileUtils.CombinePaths(Project.ProjectDirectory.FullName,
outFile);
}
return outFile;
}
#endregion Private Instance Methods
#region Private Static Methods
///
/// Gets the value of the specified attribute from the specified node.
///
/// The node of which the attribute value should be retrieved.
/// The attribute of which the value should be returned.
///
/// The value of the attribute with the specified name or
/// if the attribute does not exist or has no value.
///
private static string GetXmlAttributeValue(XmlNode xmlNode, string attributeName) {
string attributeValue = null;
if (xmlNode != null) {
XmlAttribute xmlAttribute = (XmlAttribute) xmlNode.Attributes.GetNamedItem(attributeName);
if (xmlAttribute != null) {
attributeValue = StringUtils.ConvertEmptyToNull(xmlAttribute.Value);
}
}
return attributeValue;
}
#endregion Private Static Methods
#region Private Instance Fields
private readonly string _rawRelativeOutputDir;
private readonly string _rawIntermediateDir;
private readonly string _rawReferencesPath;
private readonly ConfigurationType _type;
private readonly bool _wholeProgramOptimization;
private readonly bool _managedExtensions;
private readonly CharacterSet _characterSet = CharacterSet.NotSet;
private readonly UseOfMFC _useOfMFC = UseOfMFC.NotUsing;
private readonly UseOfATL _useOfATL = UseOfATL.NotUsing;
private readonly LinkerConfig _linkerConfiguration;
private bool _initialized;
///
/// Holds the output path for this build configuration.
///
///
/// Lazy initialized by .
///
private string _outputPath;
///
/// Holds list of files to link in the order in which they are defined
/// in the project file.
///
private readonly ArrayList _objFiles = new ArrayList();
///
/// Holds the C++ sources for each build configuration.
///
///
/// The key of the hashtable is a build configuration, and the
/// value is an ArrayList holding the C++ source files for that
/// build configuration.
///
private readonly Hashtable _sourceConfigs = new Hashtable();
///
/// Holds the resources for each build configuration.
///
///
/// The key of the hashtable is a build configuration, and the
/// value is an ArrayList holding the resources files for that
/// build configuration.
///
private readonly Hashtable _rcConfigs = new Hashtable();
///
/// Holds the IDL files for each build configuration.
///
///
/// The key of the hashtable is a build configuration, and the
/// value is an ArrayList holding the IDL files for that build
/// configuration.
///
private readonly Hashtable _idlConfigs = new Hashtable();
#endregion Private Instance Fields
///
/// The type of output for a given configuration.
///
public enum ConfigurationType {
///
/// A Makefile.
///
Makefile = 0,
///
/// Application (.exe).
///
Application = 1,
///
/// Dynamic Library (.dll).
///
DynamicLibrary = 2,
///
/// Static Library (.lib).
///
StaticLibrary = 4,
///
/// Utility.
///
Utility = 10
}
internal class LinkerConfig {
#region Private Instance Constructor
internal LinkerConfig(VcProjectConfiguration projectConfig) {
_projectConfig = projectConfig;
}
#endregion Private Instance Constructor
#region Public Instance Properties
///
/// Gets a instance representing the
/// absolute path to the import library to generate.
///
///
/// A representing the absolute path to the
/// import library to generate, or if no
/// import library must be generated.
///
public FileInfo ImportLibrary {
get {
string defaultImportLibrary = null;
if (!Project.IsManaged(_projectConfig.SolutionTask.SolutionConfig)) {
defaultImportLibrary = "$(OutDir)/$(TargetName).lib";
}
string importLibrary = StringUtils.ConvertEmptyToNull(
_projectConfig.GetToolSetting(VcConfigurationBase.LinkerTool,
"ImportLibrary", defaultImportLibrary));
if (importLibrary == null) {
// no import library must be generated
return null;
}
if (_projectConfig.SolutionTask.OutputDir != null) {
importLibrary = FileUtils.CombinePaths(
_projectConfig.SolutionTask.OutputDir.FullName,
Path.GetFileName(importLibrary));
} else {
importLibrary = FileUtils.CombinePaths(
Project.ProjectDirectory.FullName, importLibrary);
}
return new FileInfo(importLibrary);
}
}
#endregion Public Instance Properties
#region Private Instance Properties
private VcProject Project {
get { return (VcProject) _projectConfig.Project; }
}
#endregion Private Instance Properties
#region Private Instance Fields
private readonly VcProjectConfiguration _projectConfig;
#endregion Private Instance Fields
}
}
}
nant-0.92-rc1/src/NAnt.VSNet/GenericSolution.cs 0000644 0001750 0001750 00000002666 11757302274 021130 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.CodeDom.Compiler;
using System.Collections;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
///
/// Supports grouping of individual projects, and treating them as a solution.
///
public class GenericSolution : SolutionBase {
#region Public Instance Constructors
public GenericSolution(SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver) : base(solutionTask, tfc, gacCache, refResolver) {
}
#endregion Public Instance Constructors
}
}
nant-0.92-rc1/src/NAnt.VSNet/Tasks/ 0000755 0001750 0001750 00000000000 11757310030 016530 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.VSNet/Tasks/SolutionTask.cs 0000644 0001750 0001750 00000062657 11757302274 021551 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (mmastrac at users.sourceforge.net)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.Reflection;
using System.IO;
using Microsoft.Win32;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Extensibility;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.VSNet.Extensibility;
using NAnt.VSNet.Types;
using System.Security;
using System.Security.Permissions;
using System.Security.Policy;
namespace NAnt.VSNet.Tasks {
///
/// Compiles VS.NET solutions (or sets of projects), automatically determining
/// project dependencies from inter-project references.
///
///
///
/// This task support the following projects:
///
///
///
/// Visual Basic .NET
///
///
/// Visual C# .NET
///
///
/// Visual J# .NET
///
///
/// Visual C++ .NET
///
///
///
/// Right now, only Microsoft Visual Studio .NET 2002 and 2003 solutions
/// and projects are supported. Support for .NET Compact Framework projects
/// is also not available at this time.
///
///
/// The also supports the model of referencing
/// projects by their output filenames, rather than referencing them inside
/// the solution. It will automatically detect the existance of a file
/// reference and convert it to a project reference. For example, if project
/// "A" references the file in the release output directory of
/// project "B", the will automatically
/// convert this to a project dependency on project "B" and will
/// reference the appropriate configuration output directory at the final
/// build time (ie: reference the debug version of "B" if the
/// solution is built as debug).
///
///
/// The expects all project files to be valid
/// XML files.
///
///
Resx Files
///
/// When building a project for a down-level target framework, special care
/// should be given to resx files. Resx files (can) contain references to
/// a specific version of CLR types, and as such are only upward compatible.
///
///
/// For example: if you want to be able to build a project both as a .NET 1.0
/// and .NET 1.1 assembly, the resx files should only contain references to
/// .NET 1.0 CLR types. Failure to do this may result in a
/// failure at runtime on machines with only the .NET Framework 1.0 installed.
///
///
///
///
/// Compiles all of the projects in test.sln, in release mode, in
/// the proper order.
///
///
///
/// ]]>
///
///
///
///
/// Compiles all of the projects in projects.txt, in the proper
/// order.
///
///
///
///
///
///
///
/// ]]>
///
///
///
///
/// Compiles projects A, B and C, using the output of project X as a
/// reference.
///
///
///
///
///
///
///
///
///
///
///
///
/// ]]>
///
///
///
///
/// Compiles all of the projects in the solution except for project A.
///
///
///
///
///
///
///
/// ]]>
///
///
///
///
/// Compiles all of the projects in the solution mapping the specific project at
/// http://localhost/A/A.csproj to c:\inetpub\wwwroot\A\A.csproj and any URLs under
/// http://localhost/B/[remainder] to c:\other\B\[remainder]. This allows the build
/// to work without WebDAV.
///
///
///
///
///
///
///
///
/// ]]>
///
///
///
///
/// Compiles all of the projects in the solution placing compiled outputs
/// in c:\temp.
///
///
/// ]]>
///
///
[Serializable()]
[TaskName("solution")]
[PluginConsumer(typeof(IProjectBuildProvider))]
[PluginConsumer(typeof(ISolutionBuildProvider))]
public class SolutionTask : Task, IPluginConsumer {
///
/// Private var containing custom properties.
///
ArrayList _customproperties;
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public SolutionTask() {
_customproperties = new ArrayList();
_projects = new FileSet();
_referenceProjects = new FileSet();
_excludeProjects = new FileSet();
_assemblyFolders = new FileSet();
_webMaps = new WebMapCollection();
_projectFactory = ProjectFactory.Create(this);
_solutionFactory = SolutionFactory.Create();
_configuration = new Configuration ();
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// The projects to build.
///
[BuildElement("projects", Required=false)]
public FileSet Projects {
get { return _projects; }
set { _projects = value; }
}
///
/// The projects to scan, but not build.
///
///
/// These projects are used to resolve project references and are
/// generally external to the solution being built. References to
/// these project's output files are converted to use the appropriate
/// solution configuration at build time.
///
[BuildElement("referenceprojects", Required=false)]
public FileSet ReferenceProjects {
get { return _referenceProjects; }
set { _referenceProjects = value; }
}
///
/// The name of the VS.NET solution file to build.
///
///
///
/// The can be used instead to supply a list
/// of Visual Studio.NET projects that should be built.
///
///
[TaskAttribute("solutionfile", Required=false)]
public FileInfo SolutionFile {
get { return _solutionFile; }
set { _solutionFile = value; }
}
///
/// The name of the solution configuration to build.
///
///
///
/// Generally release or debug. Not case-sensitive.
///
///
[TaskAttribute("configuration", Required=true)]
[StringValidator(AllowEmpty=false)]
public string Configuration {
get { return _configuration.Name; }
set { _configuration.Name = StringUtils.ConvertEmptyToNull(value); }
}
///
/// The name of platform to build the solution for.
///
[TaskAttribute("platform", Required=false)]
[StringValidator(AllowEmpty=true)]
public string Platform {
get { return _configuration.Platform; }
set { _configuration.Platform = value; }
}
///
/// Gets the solution configuration to build.
///
public Configuration SolutionConfig {
get { return _configuration; }
}
///
/// The directory where compiled targets will be placed. This
/// overrides path settings contained in the solution/project.
///
[TaskAttribute("outputdir", Required=false)]
public DirectoryInfo OutputDir {
get { return _outputDir; }
set { _outputDir = value; }
}
///
/// WebMap of URL's to project references.
///
[BuildElementCollection("webmap", "map")]
public WebMapCollection WebMaps {
get { return _webMaps; }
}
///
/// Fileset of projects to exclude.
///
[BuildElement("excludeprojects", Required=false)]
public FileSet ExcludeProjects {
get { return _excludeProjects; }
set { _excludeProjects = value; }
}
///
/// Set of folders where references are searched when not found in path
/// from project file (HintPath).
///
[BuildElement("assemblyfolders", Required=false)]
public FileSet AssemblyFolders {
get { return _assemblyFolders; }
set { _assemblyFolders = value; }
}
///
/// Includes Visual Studio search folders in reference search path.
/// The default is .
///
[TaskAttribute("includevsfolders")]
[BooleanValidator()]
public bool IncludeVSFolders {
get { return _includeVSFolders; }
set { _includeVSFolders = value; }
}
///
/// Allow the task to use WebDAV for retrieving/compiling the projects within solution. Use of
/// is preferred over WebDAV. The default is .
///
///
/// WebDAV support requires permission changes to be made on your project server. These changes may affect
/// the security of the server and should not be applied to a public installation.
/// Consult your web server or the NAnt Wiki documentation for more information.
///
[TaskAttribute("enablewebdav", Required = false)]
[BooleanValidator()]
public bool EnableWebDav {
get { return _enableWebDav; }
set { _enableWebDav = value; }
}
///
/// Set of properties set at solution level. Builders for projects in solution may or may not use them.
///
///
///
/// TODO: some documentataion which properties could be defined here.
///
///
[BuildElementArray("property", ElementType = typeof(PropertyTask))]
public ArrayList CustomProperties {
get { return _customproperties; }
}
///
/// Gets the list of folders to scan for assembly references.
///
///
/// The list of folders to scan for assembly references.
///
public StringCollection AssemblyFolderList {
get {
if (_assemblyFolderList == null) {
_assemblyFolderList = new StringCollection();
foreach (string folder in AssemblyFolders.DirectoryNames) {
if (!_assemblyFolderList.Contains(folder)) {
_assemblyFolderList.Add(folder);
Log(Level.Debug, "Added \"{0}\" to AssemblyFolders.",
folder);
}
}
if (IncludeVSFolders) {
StringCollection vsAssemblyFolders = BuildAssemblyFolders();
foreach (string folder in vsAssemblyFolders) {
if (!_assemblyFolderList.Contains(folder)) {
_assemblyFolderList.Add(folder);
Log(Level.Debug, "Added \"{0}\" to AssemblyFolders.",
folder);
}
}
}
}
return _assemblyFolderList;
}
}
#endregion Public Instance Properties
#region Internal Instance Properties
internal ProjectFactory ProjectFactory {
get { return _projectFactory; }
}
internal SolutionFactory SolutionFactory {
get { return _solutionFactory; }
}
#endregion Internal Instance Properties
#region Implementation of IPluginConsumer
void IPluginConsumer.ConsumePlugin(IPlugin plugin) {
if (plugin is IProjectBuildProvider)
ProjectFactory.RegisterProvider((IProjectBuildProvider) plugin);
if (plugin is ISolutionBuildProvider)
SolutionFactory.RegisterProvider((ISolutionBuildProvider) plugin);
}
#endregion Implementation of IPluginConsumer
#region Override implementation of Task
protected override void ExecuteTask() {
Log(Level.Info, "Starting solution build.");
if (SolutionFile != null) {
if (!SolutionFile.Exists) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Couldn't find solution file '{0}'.", SolutionFile.FullName),
Location);
}
}
if (Projects.FileNames.Count > 0) {
Log(Level.Verbose, "Included projects:" );
foreach (string projectFile in Projects.FileNames) {
Log(Level.Verbose, " - " + projectFile);
}
}
if (ReferenceProjects.FileNames.Count > 0) {
Log(Level.Verbose, "Reference projects:");
foreach (string projectFile in ReferenceProjects.FileNames) {
Log(Level.Verbose, " - " + projectFile);
}
}
string basePath = null;
try {
using (TempFileCollection tfc = new TempFileCollection()) {
// store the temp dir so we can clean it up later
basePath = tfc.BasePath;
// ensure temp directory exists
if (!Directory.Exists(tfc.BasePath)) {
Directory.CreateDirectory(tfc.BasePath);
}
// create temporary domain
PermissionSet tempDomainPermSet = new PermissionSet(PermissionState.Unrestricted);
AppDomain temporaryDomain = AppDomain.CreateDomain("temporaryDomain", AppDomain.CurrentDomain.Evidence,
AppDomain.CurrentDomain.SetupInformation, tempDomainPermSet);
try {
ReferencesResolver referencesResolver =
((ReferencesResolver) temporaryDomain.CreateInstanceFrom(Assembly.GetExecutingAssembly().Location,
typeof(ReferencesResolver).FullName).Unwrap());
using (GacCache gacCache = new GacCache(this.Project)) {
SolutionBase sln = SolutionFactory.LoadSolution(this,
tfc, gacCache, referencesResolver);
if (!sln.Compile(_configuration)) {
throw new BuildException("Project build failed.", Location);
}
}
} finally {
// unload temporary domain
AppDomain.Unload(temporaryDomain);
}
}
} finally {
if (basePath != null && Directory.Exists(basePath)) {
Log(Level.Debug, "Cleaning up temp folder '{0}'.", basePath);
// delete temporary directory and all files in it
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = Project;
deleteTask.Parent = this;
deleteTask.InitializeTaskConfiguration();
deleteTask.Directory = new DirectoryInfo(basePath);
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
}
}
#endregion Override implementation of Task
#region Internal Instance Methods
///
/// Expands the given macro.
///
/// The macro to expand.
///
/// The expanded macro or if the macro is not
/// supported.
///
/// The macro cannot be expanded.
internal string ExpandMacro(string macro) {
// perform case-insensitive expansion of macros
switch (macro.ToLower(CultureInfo.InvariantCulture)) {
case "solutionfilename": // E.g. WindowsApplication1.sln
if (SolutionFile != null) {
return Path.GetFileName(SolutionFile.FullName);
} else {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Macro \"{0}\" cannot be expanded, no solution file specified.",
macro), Location.UnknownLocation);
}
case "solutionpath": // Absolute path for SolutionFileName
if (SolutionFile != null) {
return SolutionFile.FullName;
} else {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Macro \"{0}\" cannot be expanded, no solution file specified.",
macro), Location.UnknownLocation);
}
case "solutiondir": // SolutionPath without SolutionFileName appended
if (SolutionFile != null) {
return Path.GetDirectoryName(SolutionFile.FullName)
+ Path.DirectorySeparatorChar;
} else {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Macro \"{0}\" cannot be expanded, no solution file specified.",
macro), Location.UnknownLocation);
}
case "solutionname": // E.g. WindowsApplication1
if (SolutionFile != null) {
return Path.GetFileNameWithoutExtension(
SolutionFile.FullName);
} else {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Macro \"{0}\" cannot be expanded, no solution file specified.",
macro), Location.UnknownLocation);
}
case "solutionext": // Is this ever anything but .sln?
if (SolutionFile != null) {
return Path.GetExtension(SolutionFile.FullName);
} else {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Macro \"{0}\" cannot be expanded, no solution file specified.",
macro), Location.UnknownLocation);
}
default:
return null;
}
}
#endregion Internal Instance Methods
#region Private Instance Methods
///
/// Builds the list of folders that should be scanned for assembly
/// references.
///
///
/// The list of folders that should be scanned for assembly references.
///
private StringCollection BuildAssemblyFolders() {
StringCollection folderList = new StringCollection();
// determine version of Visual Studio .NET corresponding with
// current target framework
Version visualStudioVersion = Project.TargetFramework.VisualStudioVersion;
// check HKCU
BuildVisualStudioAssemblyFolders(folderList, Registry.CurrentUser,
visualStudioVersion.ToString(2));
// check HKLM
BuildVisualStudioAssemblyFolders(folderList, Registry.LocalMachine,
visualStudioVersion.ToString(2));
// check HKCU for .NET Framework AssemblyFolders
BuildDotNetAssemblyFolders(folderList, Registry.CurrentUser);
// check HKLM for .NET Framework AssemblyFolders
BuildDotNetAssemblyFolders(folderList, Registry.LocalMachine);
return folderList;
}
private void BuildVisualStudioAssemblyFolders(StringCollection folderList, RegistryKey hive, string visualStudioVersion) {
RegistryKey assemblyFolders = hive.OpenSubKey(@"SOFTWARE\Microsoft\VisualStudio\"
+ visualStudioVersion + @"\AssemblyFolders");
if (assemblyFolders == null) {
return;
}
string[] subKeyNames = assemblyFolders.GetSubKeyNames();
foreach (string subKeyName in subKeyNames) {
RegistryKey subKey = assemblyFolders.OpenSubKey(subKeyName);
string folder = subKey.GetValue(string.Empty) as string;
if (folder != null && !folderList.Contains(folder)) {
folderList.Add(folder);
}
}
}
private void BuildDotNetAssemblyFolders(StringCollection folderList, RegistryKey hive) {
RegistryKey assemblyFolders = hive.OpenSubKey(@"SOFTWARE\Microsoft\"
+ @".NETFramework\AssemblyFolders");
if (assemblyFolders == null) {
return;
}
string[] subKeyNames = assemblyFolders.GetSubKeyNames();
foreach (string subKeyName in subKeyNames) {
RegistryKey subKey = assemblyFolders.OpenSubKey(subKeyName);
string folder = subKey.GetValue(string.Empty) as string;
if (folder != null && !folderList.Contains(folder)) {
folderList.Add(folder);
}
}
}
#endregion Private Instance Methods
#region Private Instance Fields
private FileInfo _solutionFile;
private Configuration _configuration;
private DirectoryInfo _outputDir;
private FileSet _projects;
private FileSet _referenceProjects;
private FileSet _excludeProjects;
private FileSet _assemblyFolders;
private StringCollection _assemblyFolderList;
private WebMapCollection _webMaps;
private bool _includeVSFolders = true;
private bool _enableWebDav;
private readonly SolutionFactory _solutionFactory;
private readonly ProjectFactory _projectFactory;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/ProjectBase.cs 0000644 0001750 0001750 00000123017 11757302274 020212 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Dmitry Jemerov
using System;
using System.Collections;
using System.Collections.Specialized;
using System.CodeDom.Compiler;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Xml;
using Microsoft.Win32;
using NAnt.Core;
using NAnt.Core.Functions;
using NAnt.Core.Tasks;
using NAnt.Core.Util;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
///
/// Base class for all project classes.
///
public abstract class ProjectBase {
#region Protected Instance Constructors
///
/// Initializes a new instance of the class.
///
protected ProjectBase(XmlElement xmlDefinition, SolutionTask solutionTask, TempFileCollection temporaryFiles, GacCache gacCache, ReferencesResolver referencesResolver, DirectoryInfo outputDir) {
if (xmlDefinition == null) {
throw new ArgumentNullException("xmlDefinition");
}
if (solutionTask == null) {
throw new ArgumentNullException("solutionTask");
}
if (temporaryFiles == null) {
throw new ArgumentNullException("temporaryFiles");
}
if (gacCache == null) {
throw new ArgumentNullException("gacCache");
}
if (referencesResolver == null) {
throw new ArgumentNullException("referencesResolver");
}
_projectConfigurations = new ConfigurationDictionary();
_buildConfigurations = new ConfigurationDictionary();
_extraOutputFiles = CollectionsUtil.CreateCaseInsensitiveHashtable();
// ensure the specified project is actually supported by this project
VerifyProjectXml(xmlDefinition);
_solutionTask = solutionTask;
_temporaryFiles = temporaryFiles;
_outputDir = outputDir;
_gacCache = gacCache;
_refResolver = referencesResolver;
_productVersion = DetermineProductVersion(xmlDefinition);
}
#endregion Protected Instance Constructors
#region Public Instance Properties
///
/// Gets the Visual Studio product version of the project.
///
///
/// The Visual Studio product version of the project.
///
public ProductVersion ProductVersion {
get { return _productVersion; }
}
///
/// Gets the name of the VS.NET project.
///
public abstract string Name {
get;
}
///
/// Gets the type of the project.
///
///
/// The type of the project.
///
public abstract ProjectType Type {
get;
}
///
/// Gets the path of the VS.NET project.
///
public abstract string ProjectPath {
get;
}
///
/// Gets the directory containing the VS.NET project.
///
public abstract DirectoryInfo ProjectDirectory {
get;
}
///
/// Get the location of the project.
///
public abstract ProjectLocation ProjectLocation {
get;
}
///
/// Get the directory in which intermediate build output that is not
/// specific to the build configuration will be stored.
///
///
///
/// For projects, this is defined
/// as <Project Directory<\obj.
///
///
/// For projects, this is defined
/// as %HOMEPATH%\VSWebCache\<Machine Name>\<Project Directory>\obj.
///
///
public virtual DirectoryInfo ObjectDir {
get {
switch (ProjectLocation) {
case ProjectLocation.Web:
string webCachePath = FileUtils.CombinePaths(
FileUtils.GetHomeDirectory(), "VSWebCache");
string machinePath= FileUtils.CombinePaths(webCachePath,
Environment.MachineName);
string projectPath = FileUtils.CombinePaths(machinePath,
Name);
return new DirectoryInfo(FileUtils.CombinePaths(projectPath,
"obj"));
case ProjectLocation.Local:
return new DirectoryInfo(
FileUtils.CombinePaths(ProjectDirectory.FullName, "obj"));
default:
throw new NotSupportedException(ProjectLocation.ToString());
}
}
}
///
/// Gets or sets the unique identifier of the VS.NET project.
///
public abstract string Guid {
get;
set;
}
///
/// Gets a list of all configurations defined in the project.
///
public ConfigurationDictionary ProjectConfigurations {
get { return _projectConfigurations; }
}
///
/// Gets a list of project configurations that can be build.
///
///
///
/// Project configurations that are not in this list do not need to be
/// compiled.
///
///
public ConfigurationDictionary BuildConfigurations {
get { return _buildConfigurations; }
}
public abstract ArrayList References {
get;
}
public SolutionTask SolutionTask {
get { return _solutionTask; }
}
public TempFileCollection TemporaryFiles {
get { return _temporaryFiles; }
}
///
/// Gets the extra set of output files for the project.
///
///
/// The extra set of output files for the project.
///
///
/// The key of the case-insensitive is the
/// full path of the output file and the value is the path relative to
/// the output directory.
///
public Hashtable ExtraOutputFiles {
get { return _extraOutputFiles; }
}
#endregion Public Instance Properties
#region Protected Instance Properties
protected DirectoryInfo OutputDir {
get { return _outputDir; }
}
protected GacCache GacCache {
get { return _gacCache; }
}
public ReferencesResolver ReferencesResolver {
get { return _refResolver; }
}
///
/// Gets the set of projects that the project depends on.
///
///
/// The set of projects that the project depends on.
///
public ProjectBaseCollection ProjectDependencies {
get { return _projectDependencies; }
}
protected virtual string DevEnvDir {
get {
string vs7CommonDirKeyName = @"SOFTWARE\Microsoft\VisualStudio\"
+ ProductVersionNumber + @"\Setup\VS";
RegistryKey vs7CommonDirKey = Registry.LocalMachine.OpenSubKey(
vs7CommonDirKeyName);
if (vs7CommonDirKey == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Registry key \"{0}\" could not be found.", vs7CommonDirKeyName),
Location.UnknownLocation);
}
string vs7CommonDir = vs7CommonDirKey.GetValue("VS7CommonDir") as string;
if (vs7CommonDir == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Value \"VS7CommonDir\" does not exist in registry key"
+ " \"{0}\".", vs7CommonDirKeyName), Location.UnknownLocation);
}
return FileUtils.CombinePaths(vs7CommonDir, @"IDE\");
}
}
#endregion Protected Instance Properties
#region Private Instance Properties
///
/// TODO: refactor this !!!
///
private Version ProductVersionNumber {
get {
switch (ProductVersion) {
case ProductVersion.Rainier:
return new Version(7, 0);
case ProductVersion.Everett:
return new Version(7, 1);
default:
throw new Exception("Invalid product version \""
+ ProductVersion + "\".");
}
}
}
#endregion Private Instance Properties
#region Public Instance Methods
public abstract ProjectReferenceBase CreateProjectReference(
ProjectBase project, bool isPrivateSpecified, bool isPrivate);
public bool Compile(Configuration solutionConfiguration) {
ConfigurationBase projectConfig = BuildConfigurations[solutionConfiguration];
if (projectConfig == null) {
Log(Level.Info, "Skipping '{0}' [{1}] ...", Name, solutionConfiguration);
return true;
}
Log(Level.Info, "Building '{0}' [{1}] ...", Name, projectConfig.Name);
// ensure project-level object directory exists, no need to do this
// for the project-level output directory as we already this before
if (!ObjectDir.Exists) {
ObjectDir.Create();
ObjectDir.Refresh();
}
// build the project
BuildResult result = Build(solutionConfiguration);
return (result != BuildResult.Failed);
}
public string GetOutputPath(Configuration solutionConfiguration) {
// obtain project configuration (corresponding with solution configuration)
ConfigurationBase config = BuildConfigurations[solutionConfiguration];
if (config == null) {
return null;
}
return config.OutputPath;
}
public ConfigurationBase GetConfiguration(Configuration solutionConfiguration) {
// obtain project configuration (corresponding with solution configuration)
return BuildConfigurations[solutionConfiguration];
}
public StringCollection GetAssemblyReferences(Configuration solutionConfiguration) {
Hashtable uniqueReferences = CollectionsUtil.CreateCaseInsensitiveHashtable();
foreach (ReferenceBase reference in References) {
StringCollection references = reference.GetAssemblyReferences(solutionConfiguration);
// avoid ambiguous references when the same assembly is
// referenced multiple times
//
// this should only be possible for VB.NET project, as they
// also include the assemblies referenced by referenced projects
//
// Project A references
// Assembly 1
// Assembly 2
// Project B references
// Assembly 3
// Project A
//
// then to compile Project B, VB.NET will use the following
// assembly references:
//
// Assembly 1
// Assembly 2
// Assembly 3
// Project Output of Project A
//
// see bug #1178862
foreach (string assemblyFile in references) {
try {
// try to obtain AssemblyName of referenced assembly
AssemblyName assemblyName = AssemblyName.GetAssemblyName(assemblyFile);
if (!uniqueReferences.ContainsKey(assemblyName.FullName)) {
uniqueReferences.Add(assemblyName.FullName, assemblyFile);
}
} catch (Exception ex) {
// ignore assemblies that cannot be found or loaded
Log(Level.Warning, "Referenced assembly \"{0}\" could not"
+ " be loaded: {1}", assemblyFile, ex.Message);
}
}
}
StringCollection assemblyReferences = new StringCollection();
foreach (DictionaryEntry entry in uniqueReferences) {
assemblyReferences.Add((string) entry.Value);
}
return assemblyReferences;
}
///
/// Gets the complete set of output files for the project configuration
/// matching the specified solution configuration.
///
/// The solution configuration that is built.
/// The set of output files to be updated.
///
///
/// The key of the case-insensitive is the
/// full path of the output file and the value is the path relative to
/// the output directory.
///
///
/// If the project is not configured to be built for the specified
/// solution configuration, then no output files are added.
///
///
public virtual void GetOutputFiles(Configuration solutionConfiguration, Hashtable outputFiles) {
// obtain project configuration (corresponding with solution configuration)
ConfigurationBase config = BuildConfigurations[solutionConfiguration];
if (config == null) {
// the project is not configured to be built for the specified
// solution configuration
return;
}
foreach (ReferenceBase reference in References) {
if (!reference.CopyLocal) {
continue;
}
// only add output files of reference if we did not add them
// already
if (!outputFiles.ContainsKey(config.BuildPath)) {
reference.GetOutputFiles(solutionConfiguration, outputFiles);
}
}
// determine output file of project
string projectOutputFile = config.BuildPath;
// check if project has output file (eg. NMake project does not
// necessarily have an output file)
if (projectOutputFile != null && File.Exists(projectOutputFile)) {
// get list of files related to project output file (eg. debug symbols,
// xml doc, ...), this will include the project output file itself
ReferenceBase.GetRelatedFiles(projectOutputFile, outputFiles);
// NOTE:
//
// for now we assume that the extra output files do not need
// to be copied/deployed if there's no main output file or
// the main output file does not exist (eg. because of a compile
// error)
// add extra project-level output files
foreach (DictionaryEntry de in ExtraOutputFiles) {
outputFiles[(string) de.Key] = (string) de.Value;
}
// add extra configuration-level output files
foreach (DictionaryEntry de in config.ExtraOutputFiles) {
outputFiles[(string) de.Key] = (string) de.Value;
}
}
}
///
/// Gets a value indicating whether building the project for the specified
/// build configuration results in managed output.
///
/// The build configuration.
///
/// if the project output for the given build
/// configuration is managed; otherwise, .
///
public abstract bool IsManaged(Configuration configuration);
#endregion Public Instance Methods
#region Protected Internal Instance Methods
///
/// Expands the given macro.
///
/// The macro to expand.
///
/// The expanded macro or if the macro is not
/// supported.
///
protected internal virtual string ExpandMacro(string macro) {
// perform case-insensitive expansion of macros
switch (macro.ToLower(CultureInfo.InvariantCulture)) {
case "projectname": // E.g. WindowsApplication1
return Name;
case "projectpath": // E.g. C:\Doc...\Visual Studio Projects\WindowsApplications1\WindowsApplications1.csproj
return ProjectPath;
case "projectfilename": // E.g. WindowsApplication1.csproj
return Path.GetFileName(ProjectPath);
case "projectext": // .csproj
return Path.GetExtension(ProjectPath);
case "projectdir": // ProjectPath without ProjectFileName at the end
return Path.GetDirectoryName(ProjectPath)
+ Path.DirectorySeparatorChar;
case "devenvdir":
return DevEnvDir;
default:
return null;
}
}
#endregion Protected Internal Instance Methods
#region Protected Instance Methods
///
/// Returns the Visual Studio product version of the specified project
/// XML fragment.
///
/// XML fragment representing the project file.
///
/// The Visual Studio product version of the specified project XML
/// file.
///
///
/// The product version could not be determined.
/// -or-
/// The product version is not supported.
///
protected abstract ProductVersion DetermineProductVersion(XmlElement docElement);
///
/// Verifies whether the specified XML fragment represents a valid project
/// that is supported by this .
///
/// XML fragment representing the project file.
///
/// The XML fragment is not supported by this .
/// -or-
/// The XML fragment does not represent a valid project (for this ).
///
protected abstract void VerifyProjectXml(XmlElement docElement);
///
/// Prepares the project for being built.
///
/// The solution configuration that is built.
///
/// The default implementation will ensure that none of the output files
/// are marked read-only.
///
protected virtual void Prepare(Configuration solutionConfiguration) {
// determine the output files of the project
Hashtable outputFiles = CollectionsUtil.CreateCaseInsensitiveHashtable();
GetOutputFiles(solutionConfiguration, outputFiles);
// use the task to ensure none of the output files are
// marked read-only
AttribTask attribTask = new AttribTask();
// parent is solution task
attribTask.Parent = SolutionTask;
// inherit project from solution task
attribTask.Project = SolutionTask.Project;
// inherit namespace manager from solution task
attribTask.NamespaceManager = SolutionTask.NamespaceManager;
// inherit verbose setting from solution task
attribTask.Verbose = SolutionTask.Verbose;
// only output warning messages or higher, unless
// we're running in verbose mode
if (!attribTask.Verbose) {
attribTask.Threshold = Level.Warning;
}
// make sure framework specific information is set
attribTask.InitializeTaskConfiguration();
// set parent of child elements
attribTask.AttribFileSet.Parent = attribTask;
// inherit project for child elements from containing task
attribTask.AttribFileSet.Project = attribTask.Project;
// inherit namespace manager from containing task
attribTask.AttribFileSet.NamespaceManager = attribTask.NamespaceManager;
// we want to reset the read-only attribute of all output files
attribTask.ReadOnlyAttrib = false;
// obtain project configuration (corresponding with solution configuration)
ConfigurationBase config = BuildConfigurations[solutionConfiguration];
// add all output files to the fileset
foreach (DictionaryEntry de in outputFiles) {
attribTask.AttribFileSet.Includes.Add(FileUtils.CombinePaths(
config.OutputDir.FullName, (string) de.Value));
}
// increment indentation level
attribTask.Project.Indent();
try {
// execute task
attribTask.Execute();
} finally {
// restore indentation level
attribTask.Project.Unindent();
}
}
protected abstract BuildResult Build(Configuration solutionConfiguration);
///
/// Copies the specified file if the destination file does not exist, or
/// the source file has been modified since it was previously copied.
///
/// The file to copy.
/// The destination file.
/// The in which context the operation will be performed.
protected void CopyFile(FileInfo srcFile, FileInfo destFile, Task parent) {
// create instance of Copy task
CopyTask ct = new CopyTask();
// parent is solution task
ct.Parent = parent;
// inherit project from parent task
ct.Project = parent.Project;
// inherit namespace manager from parent task
ct.NamespaceManager = parent.NamespaceManager;
// inherit verbose setting from parent task
ct.Verbose = parent.Verbose;
// only output warning messages or higher, unless
// we're running in verbose mode
if (!ct.Verbose) {
ct.Threshold = Level.Warning;
}
// make sure framework specific information is set
ct.InitializeTaskConfiguration();
// set parent of child elements
ct.CopyFileSet.Parent = ct;
// inherit project for child elements from containing task
ct.CopyFileSet.Project = ct.Project;
// inherit namespace manager from containing task
ct.CopyFileSet.NamespaceManager = ct.NamespaceManager;
// set file to copy
ct.SourceFile = srcFile;
// set file
ct.ToFile = destFile;
// increment indentation level
ct.Project.Indent();
try {
// execute task
ct.Execute();
} finally {
// restore indentation level
ct.Project.Unindent();
}
}
protected bool ExecuteBuildEvent(string buildEvent, string buildCommandLine, string batchFile, string workingDirectory, ConfigurationBase config) {
// create the batch file
using (StreamWriter sw = new StreamWriter(batchFile)) {
sw.WriteLine("@echo off");
// replace any VS macros in the command line with real values
buildCommandLine = config.ExpandMacros(buildCommandLine);
// handle linebreak charaters
buildCommandLine = buildCommandLine.Replace("
", "\n");
sw.WriteLine(buildCommandLine);
sw.WriteLine("if errorlevel 1 goto EventReportError");
sw.WriteLine("goto EventEnd");
sw.WriteLine(":EventReportError");
sw.WriteLine("echo Project error: A tool returned an error code from the build event");
sw.WriteLine("exit 1");
sw.WriteLine(":EventEnd");
}
// execute the batch file
ProcessStartInfo psi = new ProcessStartInfo(batchFile);
psi.UseShellExecute = false;
psi.RedirectStandardOutput = true; // For logging
psi.WorkingDirectory = workingDirectory;
// start the process now
Process batchEvent = Process.Start(psi);
// keep logging output from the process for as long as it exists
while (true) {
string logContents = batchEvent.StandardOutput.ReadLine();
if (logContents == null) {
break;
}
Log(Level.Verbose, " [" + buildEvent.ToLower(CultureInfo.InvariantCulture)
+ "] " + logContents);
}
batchEvent.WaitForExit();
// notify if there where problems running the batch file or it
// returned errors
int exitCode = batchEvent.ExitCode;
if (exitCode == 0) {
Log(Level.Verbose, "{0} succeeded (exit code = 0)", buildEvent);
} else {
Log(Level.Error, "{0} failed with exit code = {1}", buildEvent, exitCode);
}
return (exitCode == 0) ? true : false;
}
///
/// Logs a message with the given priority.
///
/// The message priority at which the specified message is to be logged.
/// The message to be logged.
///
/// The actual logging is delegated to the underlying task.
///
protected void Log(Level messageLevel, string message) {
if (SolutionTask != null) {
SolutionTask.Log(messageLevel, message);
}
}
///
/// Logs a message with the given priority.
///
/// The message priority at which the specified message is to be logged.
/// The message to log, containing zero or more format items.
/// An array containing zero or more objects to format.
///
/// The actual logging is delegated to the underlying task.
///
protected void Log(Level messageLevel, string message, params object[] args) {
if (SolutionTask != null) {
SolutionTask.Log(messageLevel, message, args);
}
}
#endregion Protected Instance Methods
#region Private Instance Fields
private readonly ProductVersion _productVersion;
private readonly SolutionTask _solutionTask;
private readonly TempFileCollection _temporaryFiles;
private readonly DirectoryInfo _outputDir;
private readonly ConfigurationDictionary _projectConfigurations;
private readonly ConfigurationDictionary _buildConfigurations;
private readonly GacCache _gacCache;
private readonly ReferencesResolver _refResolver;
private readonly Hashtable _extraOutputFiles;
private readonly ProjectBaseCollection _projectDependencies = new ProjectBaseCollection();
#endregion Private Instance Fields
}
///
/// Specifies the type of the project.
///
public enum ProjectType {
///
/// A Visual Basic.NET project.
///
VB = 0,
///
/// A Visual C# project.
///
CSharp = 1,
///
/// A Visual C++ project.
///
VisualC = 2,
///
/// A Visual J# project.
///
JSharp = 3,
///
/// MSBuild project.
///
MSBuild = 4
}
///
/// Specifies the result of the build.
///
public enum BuildResult
{
///
/// The build failed.
///
Failed = 0,
///
/// The build succeeded.
///
Success = 1,
///
/// The build succeeded and the output was updated.
///
SuccessOutputUpdated = 2,
}
public enum ProductVersion {
///
/// Visual Studio.NET 2002
///
Rainier = 70,
///
/// Visual Studio.NET 2003
///
Everett = 71,
///
/// Visual Studio 2005
///
Whidbey = 80,
///
/// Visual Studio 2008
///
Orcas = 90,
///
/// Visual Studio 2010
///
Rosario = 100,
}
///
/// Indentifies the physical location of a managed project.
///
public enum ProjectLocation {
///
/// A local project.
///
Local = 1,
///
/// A web project.
///
Web = 2,
}
///
/// Contains a collection of elements.
///
[Serializable()]
public class ProjectBaseCollection : CollectionBase {
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public ProjectBaseCollection() {
}
///
/// Initializes a new instance of the class
/// with the specified instance.
///
public ProjectBaseCollection(ProjectBaseCollection value) {
AddRange(value);
}
///
/// Initializes a new instance of the class
/// with the specified array of instances.
///
public ProjectBaseCollection(ProjectBase[] value) {
AddRange(value);
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets or sets the element at the specified index.
///
/// The zero-based index of the element to get or set.
[System.Runtime.CompilerServices.IndexerName("Item")]
public ProjectBase this[int index] {
get { return (ProjectBase) base.List[index]; }
set { base.List[index] = value; }
}
///
/// Gets the with the specified GUID.
///
/// The GUID of the to get.
///
/// Performs a case-insensitive lookup.
///
[System.Runtime.CompilerServices.IndexerName("Item")]
public ProjectBase this[string guid] {
get {
if (guid == null) {
throw new ArgumentNullException("guid");
}
// try to locate instance by guid (case-insensitive)
foreach (ProjectBase project in base.List) {
if (string.Compare(project.Guid, guid, true, CultureInfo.InvariantCulture) == 0) {
return project;
}
}
return null;
}
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Adds a to the end of the collection.
///
/// The to be added to the end of the collection.
/// The position into which the new element was inserted.
public int Add(ProjectBase item) {
return base.List.Add(item);
}
///
/// Adds the elements of a array to the end of the collection.
///
/// The array of elements to be added to the end of the collection.
public void AddRange(ProjectBase[] items) {
for (int i = 0; (i < items.Length); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Adds the elements of a to the end of the collection.
///
/// The to be added to the end of the collection.
public void AddRange(ProjectBaseCollection items) {
for (int i = 0; (i < items.Count); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Determines whether a is in the collection.
///
/// The to locate in the collection.
///
/// if is found in the
/// collection; otherwise, .
///
public bool Contains(ProjectBase item) {
return base.List.Contains(item);
}
///
/// Determines whether a with the specified
/// GUID is in the collection, using a case-insensitive lookup.
///
/// The GUID to locate in the collection.
///
/// if a with GUID
/// is found in the collection; otherwise,
/// .
///
public bool Contains(string value) {
return this[value] != null;
}
///
/// Copies the entire collection to a compatible one-dimensional array, starting at the specified index of the target array.
///
/// The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.
/// The zero-based index in at which copying begins.
public void CopyTo(ProjectBase[] array, int index) {
base.List.CopyTo(array, index);
}
///
/// Retrieves the index of a specified object in the collection.
///
/// The object for which the index is returned.
///
/// The index of the specified . If the is not currently a member of the collection, it returns -1.
///
public int IndexOf(ProjectBase item) {
return base.List.IndexOf(item);
}
///
/// Inserts a into the collection at the specified index.
///
/// The zero-based index at which should be inserted.
/// The to insert.
public void Insert(int index, ProjectBase item) {
base.List.Insert(index, item);
}
///
/// Returns an enumerator that can iterate through the collection.
///
///
/// A for the entire collection.
///
public new ProjectBaseEnumerator GetEnumerator() {
return new ProjectBaseEnumerator(this);
}
///
/// Removes a member from the collection.
///
/// The to remove from the collection.
public void Remove(ProjectBase item) {
base.List.Remove(item);
}
///
/// Remove items with the specified guid from the collection.
///
/// The guid of the project to remove from the collection.
public void Remove(string guid) {
ProjectBase removeProject = null;
// try to locate instance by guid (case-insensitive)
foreach (ProjectBase project in base.List) {
if (string.Compare(project.Guid, guid, true, CultureInfo.InvariantCulture) == 0) {
removeProject = project;
break;
}
}
if (removeProject != null) {
base.InnerList.Remove(removeProject);
}
}
#endregion Public Instance Methods
}
///
/// Enumerates the elements of a .
///
public class ProjectBaseEnumerator : IEnumerator {
#region Internal Instance Constructors
///
/// Initializes a new instance of the class
/// with the specified .
///
/// The collection that should be enumerated.
internal ProjectBaseEnumerator(ProjectBaseCollection arguments) {
IEnumerable temp = (IEnumerable) (arguments);
_baseEnumerator = temp.GetEnumerator();
}
#endregion Internal Instance Constructors
#region Implementation of IEnumerator
///
/// Gets the current element in the collection.
///
///
/// The current element in the collection.
///
public ProjectBase Current {
get { return (ProjectBase) _baseEnumerator.Current; }
}
object IEnumerator.Current {
get { return _baseEnumerator.Current; }
}
///
/// Advances the enumerator to the next element of the collection.
///
///
/// if the enumerator was successfully advanced
/// to the next element; if the enumerator has
/// passed the end of the collection.
///
public bool MoveNext() {
return _baseEnumerator.MoveNext();
}
bool IEnumerator.MoveNext() {
return _baseEnumerator.MoveNext();
}
///
/// Sets the enumerator to its initial position, which is before the
/// first element in the collection.
///
public void Reset() {
_baseEnumerator.Reset();
}
void IEnumerator.Reset() {
_baseEnumerator.Reset();
}
#endregion Implementation of IEnumerator
#region Private Instance Fields
private IEnumerator _baseEnumerator;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/VcConfigurationBase.cs 0000644 0001750 0001750 00000032426 11757302274 021707 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Dmitry Jemerov
// Scott Ford (sford@RJKTECH.com)
// Gert Driesen (drieseng@users.sourceforge.net)
// Hani Atassi (haniatassi@users.sourceforge.net)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VisualCpp.Types;
using NAnt.VSNet.Types;
namespace NAnt.VSNet {
///
/// A single build configuration for a Visual C++ project or for a specific
/// file in the project.
///
public abstract class VcConfigurationBase : ConfigurationBase {
#region Delegates
public delegate string ExpansionHandler(string value);
#endregion Delegates
#region Protected Instance Constructors
protected VcConfigurationBase(XmlElement elem, ProjectBase parentProject, DirectoryInfo outputDir) : base(parentProject) {
if (elem == null) {
throw new ArgumentNullException("elem");
}
// output directory override (if specified)
_outputDir = outputDir;
// get name of configuration (also contains the targeted platform)
_name = elem.GetAttribute("Name");
XmlNodeList tools = elem.GetElementsByTagName("Tool");
foreach (XmlElement toolElem in tools) {
string toolName = toolElem.GetAttribute("Name");
Hashtable htToolSettings = CollectionsUtil.CreateCaseInsensitiveHashtable();
foreach(XmlAttribute attr in toolElem.Attributes) {
if (attr.Name != "Name") {
htToolSettings[attr.Name] = attr.Value;
}
}
Tools[toolName] = htToolSettings;
}
}
protected VcConfigurationBase(string configName, ProjectBase parentProject, DirectoryInfo outputDir) : base(parentProject) {
_name = configName;
// set output directory (if specified)
_outputDir = outputDir;
}
#endregion Protected Instance Constructors
#region Public Instance Properties
///
/// Gets the intermediate directory, specified relative to project
/// directory.
///
///
/// The intermediate directory, specified relative to project directory.
///
public abstract string IntermediateDir {
get;
}
///
/// Gets a comma-separated list of directories to scan for assembly
/// references.
///
///
/// A comma-separated list of directories to scan for assembly
/// references, or if no additional directories
/// should scanned.
///
public abstract string ReferencesPath {
get;
}
public UsePrecompiledHeader UsePrecompiledHeader {
get {
string usePCHString = GetToolSetting("VCCLCompilerTool",
"UsePrecompiledHeader");
if (usePCHString == null) {
return UsePrecompiledHeader.Unspecified;
}
int intVal = int.Parse(usePCHString, CultureInfo.InvariantCulture);
if (this.Project.ProductVersion >= ProductVersion.Whidbey) {
switch(intVal) {
case 0 :
return UsePrecompiledHeader.No;
case 1:
return UsePrecompiledHeader.Create;
case 2:
return UsePrecompiledHeader.Use;
}
}
return (UsePrecompiledHeader) Enum.ToObject(typeof(UsePrecompiledHeader), intVal);
}
}
#endregion Public Instance Properties
#region Internal Instance Properties
///
/// Gets the name of the configuration, including the platform it
/// targets.
///
///
/// Tthe name of the configuration, including the platform it targets.
///
internal string FullName {
get { return _name; }
}
#endregion Internal Instance Properties
#region Override implementation of ConfigurationBase
///
/// Gets the output directory.
///
public override DirectoryInfo OutputDir {
get {
if (_outputDir == null) {
if (RelativeOutputDir != null) {
_outputDir = new DirectoryInfo(FileUtils.CombinePaths(
Project.ProjectDirectory.FullName, RelativeOutputDir));
} else {
throw new BuildException("The output directory could not be"
+ " determined.", Location.UnknownLocation);
}
}
return _outputDir;
}
}
///
/// Gets the path in which the output file will be created before its
/// copied to the actual output path.
///
///
/// For Visual C++ projects, the output file will be immediately
/// created in the output path.
///
public override string BuildPath {
get { return OutputPath; }
}
///
/// Gets the name of the configuration.
///
///
/// The name of the configuration.
///
public override string Name {
get {
int index = _name.IndexOf("|");
if (index >= 0) {
return _name.Substring(0, index);
}
else {
return _name;
}
}
}
///
/// Gets the platform that the configuration targets.
///
///
/// The platform targeted by the configuration.
///
public override string PlatformName {
get {
int index = _name.IndexOf("|");
if (index >= 0) {
if (index < _name.Length) {
return _name.Substring(index + 1, _name.Length - 1 - index);
} else {
return string.Empty;
}
} else {
return string.Empty;
}
}
}
///
/// Expands the given macro.
///
/// The macro to expand.
///
/// The expanded macro.
///
///
/// The macro is not supported.
/// -or-
/// The macro is not implemented.
/// -or-
/// The macro cannot be expanded.
///
protected internal override string ExpandMacro(string macro) {
// perform case-insensitive expansion of macros
switch (macro.ToLower(CultureInfo.InvariantCulture)) {
case "noinherit":
return "$(noinherit)";
case "intdir":
return IntermediateDir;
case "vcinstalldir":
throw new NotImplementedException(string.Format(CultureInfo.InvariantCulture,
"\"{0}\" macro is not yet implemented.", macro));
case "vsinstalldir":
throw new NotImplementedException(string.Format(CultureInfo.InvariantCulture,
"\"{0}\" macro is not yet implemented.", macro));
case "frameworkdir":
return SolutionTask.Project.TargetFramework.FrameworkDirectory.
Parent.FullName;
case "frameworkversion":
return "v" + SolutionTask.Project.TargetFramework.ClrVersion;
case "frameworksdkdir":
if (SolutionTask.Project.TargetFramework.SdkDirectory != null) {
return SolutionTask.Project.TargetFramework.SdkDirectory.FullName;
} else {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Macro \"{0}\" cannot be expanded: the SDK for {0}"
+ " is not installed.", SolutionTask.Project.TargetFramework.Description),
Location.UnknownLocation);
}
default:
try {
return base.ExpandMacro(macro);
} catch (BuildException) {
// Visual C++ also supports environment variables
string envvar = Environment.GetEnvironmentVariable(macro);
if (envvar != null) {
return envvar;
} else {
// re-throw build exception
throw;
}
}
}
}
#endregion Override implementation of ConfigurationBase
#region Public Instance Methods
///
/// Gets the value of a given setting for a specified tool.
///
/// The name of the tool.
/// The name of the setting.
///
/// The value of a setting for the specified tool, or
/// if the setting is not defined for the specified tool.
///
///
/// An empty setting value, which is used as a means to override the
/// project default, will be returned as a empty .
///
public string GetToolSetting(string toolName, string settingName) {
return GetToolSetting(toolName, settingName, (string) null);
}
///
/// Gets the value of a given setting for a specified tool.
///
/// The name of the tool.
/// The name of the setting.
/// The value to return if setting is not defined.
///
/// The value of a setting for the specified tool, or
/// if the setting is not defined for
/// the specified tool.
///
///
/// An empty setting value, which is used as a means to override the
/// project default, will be returned as a empty .
///
public abstract string GetToolSetting(string toolName, string settingName, string defaultValue);
public Hashtable GetToolArguments(string toolName, VcArgumentMap argMap) {
return GetToolArguments(toolName, argMap, VcArgumentMap.ArgGroup.Unassigned);
}
public abstract Hashtable GetToolArguments(string toolName, VcArgumentMap argMap, VcArgumentMap.ArgGroup ignoreGroup);
#endregion Public Instance Methods
#region Protected Instance Fields
protected readonly Hashtable Tools = CollectionsUtil.CreateCaseInsensitiveHashtable();
#endregion Protected Instance Fields
#region Private Instance Fields
private readonly string _name;
private DirectoryInfo _outputDir;
#endregion Private Instance Fields
#region Internal Static Fields
internal const string CLCompilerTool = "VCCLCompilerTool";
internal const string CustomBuildTool = "VCCustomBuildTool";
internal const string LinkerTool = "VCLinkerTool";
internal const string LibTool = "VCLibrarianTool";
internal const string ResourceCompilerTool = "VCResourceCompilerTool";
internal const string MIDLTool = "VCMIDLTool";
internal const string PreBuildEventTool = "VCPreBuildEventTool";
internal const string PostBuildEventTool = "VCPostBuildEventTool";
internal const string PreLinkEventTool = "VCPreLinkEventTool";
internal const string NMakeTool = "VCNMakeTool";
#endregion Internal Static Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/VBProjectProvider.cs 0000644 0001750 0001750 00000003671 11757302274 021365 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Martin Aliger (martin_aliger@myrealbox.com)
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Extensibility;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
internal class VBProjectProvider : IProjectBuildProvider {
#region Implementation of IProjectBuildProvider
public int IsSupported(string projectExt, XmlElement xmlDefinition) {
if (projectExt == ".vbproj")
return 5;
if (VBProject.IsSupported(xmlDefinition))
return 10;
return 0;
}
public ProjectBase GetInstance(SolutionBase solution, string projectPath, XmlElement xmlDefinition, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver, DirectoryInfo outputDir) {
return new VBProject(solution, projectPath, xmlDefinition, solutionTask, tfc, gacCache, refResolver, outputDir);
}
public string LoadGuid(XmlElement xmlDefinition) {
return VBProject.LoadGuid(xmlDefinition);
}
#endregion Implementation of IProjectBuildProvider
}
}
nant-0.92-rc1/src/NAnt.VSNet/ProjectEntry.cs 0000644 0001750 0001750 00000035324 11757302274 020444 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2008 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net.be)
using System;
using System.Collections;
using System.Globalization;
using System.Runtime.CompilerServices;
using NAnt.Core;
namespace NAnt.VSNet {
public class ProjectEntry {
#region Private Instance Fields
private readonly string _guid;
private readonly string _path;
private ProjectBase _project;
private ConfigurationMap _buildConfigurations;
#endregion Private Instance Fields
#region Public Instance Constructors
public ProjectEntry(string guid, string path) {
if (guid == null) {
throw new ArgumentNullException("guid");
}
if (path == null) {
throw new ArgumentNullException("path");
}
_guid = guid;
_path = path;
}
#endregion Public Instance Constructors
#region Public Instance Properties
public string Guid {
get { return _guid; }
}
public string Path {
get { return _path; }
}
///
/// Gets or sets the in memory representation of the project.
///
///
/// The in memory representation of the project, or
/// if the project is not (yet) loaded.
///
///
/// This property will always be for
/// projects that are not supported.
///
public ProjectBase Project {
get { return _project; }
set {
if (value != null) {
// if the project GUID from the solution file doesn't match the
// project GUID from the project file we will run into problems.
// Alert the user to fix this as it is basically a corruption
// probably caused by user manipulation of the solution file
// i.e. copy and paste
if (string.Compare(Guid, value.Guid, true, CultureInfo.InvariantCulture) != 0) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"GUID corruption detected for project '{0}'. GUID values"
+ " in project file and solution file do not match ('{1}'"
+ " and '{2}'). Please correct this manually.", value.Name,
value.Guid, Guid), Location.UnknownLocation);
}
}
_project = value;
}
}
///
/// Return a mapping between the configurations defined in the
/// solution file and the project build configurations.
///
///
/// Mapping between configurations defined in the solution file
/// and the project build configurations, or
/// if the project is not defined in a solution file.
///
///
/// This mapping only includes project build configurations that
/// are configured to be built for a given solution configuration.
///
public ConfigurationMap BuildConfigurations {
get { return _buildConfigurations; }
set { _buildConfigurations = value; }
}
#endregion Public Instance Properties
}
///
/// Contains a collection of elements.
///
[Serializable()]
public class ProjectEntryCollection : CollectionBase {
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public ProjectEntryCollection() {
}
///
/// Initializes a new instance of the class
/// with the specified instance.
///
public ProjectEntryCollection(ProjectEntryCollection value) {
AddRange(value);
}
///
/// Initializes a new instance of the class
/// with the specified array of instances.
///
public ProjectEntryCollection(ProjectEntry[] value) {
AddRange(value);
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets or sets the element at the specified index.
///
/// The zero-based index of the element to get or set.
[IndexerName("Item")]
public ProjectEntry this[int index] {
get { return (ProjectEntry) base.List[index]; }
set { base.List[index] = value; }
}
///
/// Gets the with the specified GUID.
///
/// The GUID of the to get.
///
/// Performs a case-insensitive lookup.
///
[IndexerName("Item")]
public ProjectEntry this[string guid] {
get {
if (guid != null) {
// try to locate instance by guid (case-insensitive)
for (int i = 0; i < base.Count; i++) {
ProjectEntry projectEntry = (ProjectEntry) base.List[i];
if (string.Compare(projectEntry.Guid, guid, true, CultureInfo.InvariantCulture) == 0) {
return projectEntry;
}
}
}
return null;
}
set {
if (guid == null) {
throw new ArgumentNullException ("guid");
}
if (value == null) {
throw new ArgumentNullException ("value");
}
if (!Contains (guid)) {
Add(value);
}
}
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Adds a to the end of the collection.
///
/// The to be added to the end of the collection.
///
/// The position into which the new element was inserted.
///
public int Add(ProjectEntry item) {
if (item == null) {
throw new ArgumentNullException("item");
}
// fail if a project with the same GUID exists in the collection
ProjectEntry existingEntry = this[item.Guid];
if (existingEntry != null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"The GUIDs of projects \"{0}\" and \"{1}\" are identical."
+ " Please correct this manually.", item.Path,
existingEntry.Path), Location.UnknownLocation);
}
return base.List.Add(item);
}
///
/// Adds the elements of a array to the end of the collection.
///
/// The array of elements to be added to the end of the collection.
public void AddRange(ProjectEntry[] items) {
for (int i = 0; (i < items.Length); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Adds the elements of a to the end of the collection.
///
/// The to be added to the end of the collection.
public void AddRange(ProjectEntryCollection items) {
for (int i = 0; (i < items.Count); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Determines whether a is in the collection.
///
/// The to locate in the collection.
///
/// if is found in the
/// collection; otherwise, .
///
public bool Contains(ProjectEntry item) {
return base.List.Contains(item);
}
///
/// Determines whether a with the specified
/// GUID is in the collection, using a case-insensitive lookup.
///
/// The GUID to locate in the collection.
///
/// if a with GUID
/// is found in the collection; otherwise,
/// .
///
public bool Contains(string value) {
return this[value] != null;
}
///
/// Copies the entire collection to a compatible one-dimensional array, starting at the specified index of the target array.
///
/// The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.
/// The zero-based index in at which copying begins.
public void CopyTo(ProjectEntry[] array, int index) {
base.List.CopyTo(array, index);
}
///
/// Retrieves the index of a specified object in the collection.
///
/// The object for which the index is returned.
///
/// The index of the specified . If the is not currently a member of the collection, it returns -1.
///
public int IndexOf(ProjectEntry item) {
return base.List.IndexOf(item);
}
///
/// Inserts a into the collection at the specified index.
///
/// The zero-based index at which should be inserted.
/// The to insert.
public void Insert(int index, ProjectEntry item) {
base.List.Insert(index, item);
}
///
/// Returns an enumerator that can iterate through the collection.
///
///
/// A for the entire collection.
///
public new ProjectEntryEnumerator GetEnumerator() {
return new ProjectEntryEnumerator(this);
}
///
/// Removes a member from the collection.
///
/// The to remove from the collection.
public void Remove(ProjectEntry item) {
base.List.Remove(item);
}
#endregion Public Instance Methods
}
///
/// Enumerates the elements of a .
///
public class ProjectEntryEnumerator : IEnumerator {
#region Internal Instance Constructors
///
/// Initializes a new instance of the class
/// with the specified .
///
/// The collection that should be enumerated.
internal ProjectEntryEnumerator(ProjectEntryCollection arguments) {
IEnumerable temp = (IEnumerable) (arguments);
_baseEnumerator = temp.GetEnumerator();
}
#endregion Internal Instance Constructors
#region Implementation of IEnumerator
///
/// Gets the current element in the collection.
///
///
/// The current element in the collection.
///
public ProjectEntry Current {
get { return (ProjectEntry) _baseEnumerator.Current; }
}
object IEnumerator.Current {
get { return _baseEnumerator.Current; }
}
///
/// Advances the enumerator to the next element of the collection.
///
///
/// if the enumerator was successfully advanced
/// to the next element; if the enumerator has
/// passed the end of the collection.
///
public bool MoveNext() {
return _baseEnumerator.MoveNext();
}
bool IEnumerator.MoveNext() {
return _baseEnumerator.MoveNext();
}
///
/// Sets the enumerator to its initial position, which is before the
/// first element in the collection.
///
public void Reset() {
_baseEnumerator.Reset();
}
void IEnumerator.Reset() {
_baseEnumerator.Reset();
}
#endregion Implementation of IEnumerator
#region Private Instance Fields
private IEnumerator _baseEnumerator;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/VcWrapperReference.cs 0000644 0001750 0001750 00000026300 11757302274 021536 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
// Scott Ford (sford@RJKTECH.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Globalization;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Tasks;
using NAnt.Core.Util;
using NAnt.Core.Types;
using NAnt.Win32.Tasks;
namespace NAnt.VSNet {
public class VcWrapperReference : WrapperReferenceBase {
#region Public Instance Constructors
public VcWrapperReference(XmlElement xmlDefinition, ReferencesResolver referencesResolver, ProjectBase parent, GacCache gacCache) : base(xmlDefinition, referencesResolver, parent, gacCache) {
// determine name of type library
_name = GetTypeLibraryName(GetTypeLibrary());
// determine wrapper tool
XmlAttribute toolAttribute = XmlDefinition.Attributes["WrapperTool"];
if (toolAttribute == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Wrapper tool for reference \"{0}\" in project \"{1}\" could"
+ " not be determined.", Name, Parent.Name),
Location.UnknownLocation);
}
_wrapperTool = toolAttribute.Value;
// determine if there's a primary interop assembly for the typelib
_primaryInteropAssembly = GetPrimaryInteropAssembly();
// determine filename of wrapper assembly
_wrapperAssembly = ResolveWrapperAssembly();
}
#endregion Public Instance Constructors
#region Override implementation of ReferenceBase
///
/// Gets the name of the referenced assembly.
///
///
/// The name of the referenced assembly.
///
public override string Name {
get { return _name; }
}
#endregion Override implementation of ReferenceBase
#region Override implementation of WrapperReferenceBase
///
/// Gets the name of the tool that should be used to create the
/// .
///
///
/// The name of the tool that should be used to create the
/// .
///
public override string WrapperTool {
get { return _wrapperTool; }
}
///
/// Gets the path of the wrapper assembly.
///
///
/// The path of the wrapper assembly.
///
///
/// The wrapper assembly is stored in the object directory of the
/// project.
///
public override string WrapperAssembly {
get { return _wrapperAssembly; }
}
///
/// Gets the path of the Primary Interop Assembly.
///
///
/// The path of the Primary Interop Assembly, or
/// if not available.
///
protected override string PrimaryInteropAssembly {
get { return _primaryInteropAssembly; }
}
///
/// Gets the hex version of the type library as defined in the definition
/// of the reference.
///
///
/// The hex version of the type library.
///
/// The definition of the reference does not contain a "ControlVersion" attribute.
protected override string TypeLibVersion {
get {
XmlAttribute versionAttribute = XmlDefinition.Attributes["ControlVersion"];
if (versionAttribute == null) {
throw new BuildException("The definition of the reference"
+ " does not contain a \"ControlVersion\" attribute.");
}
Version version = new Version(versionAttribute.Value);
return version.Major.ToString("x") + "." + version.Minor.ToString("x");
}
}
///
/// Gets the GUID of the type library as defined in the definition
/// of the reference.
///
///
/// The GUID of the type library.
///
protected override string TypeLibGuid {
get {
XmlAttribute guidAttribute = XmlDefinition.Attributes["ControlGUID"];
if (guidAttribute == null) {
throw new BuildException("The definition of the reference"
+ " does not contain a \"ControlGUID\" attribute.");
}
return guidAttribute.Value;
}
}
///
/// Gets the locale of the type library in hex notation.
///
///
/// The locale of the type library.
///
protected override string TypeLibLocale {
get {
XmlAttribute localeAttribute = XmlDefinition.Attributes["ControlLocale"];
if (localeAttribute != null) {
return int.Parse(localeAttribute.Value).ToString("x");
}
return "0";
}
}
#endregion Override implementation of WrapperReferenceBase
#region Private Instance Methods
protected override void ImportTypeLibrary() {
TlbImpTask tlbImp = new TlbImpTask();
// parent is solution task
tlbImp.Parent = SolutionTask;
// inherit project from solution task
tlbImp.Project = SolutionTask.Project;
// inherit namespace manager from solution task
tlbImp.NamespaceManager = SolutionTask.NamespaceManager;
// inherit verbose setting from solution task
tlbImp.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
tlbImp.InitializeTaskConfiguration();
tlbImp.TypeLib = new FileInfo(GetTypeLibrary());
tlbImp.OutputFile = new FileInfo(WrapperAssembly);
// use other imported type libraries to resolve references
//
// there's one serious limitation in the current implementation:
//
// if type library A references type library B, then we should
// first import type library B and use a reference to that
// imported type library when we import type library A.
//
// however, we have no way to find out in which order the type
// libraries should be imported. So only if type library B is
// first listed in the project file, it will work fine.
//
// we should find a way to analyse a type library to determine
// dependencies on other type libraries
//
// according to JR (jrv72@users.sourceforge.net) a possible
// solution could be to "use TypeLibConverter.ConvertTypeLibToAssembly.
// This has a callback of type ITypeLibImporterNotifySink, which I
// speculate allows one to recognize when one type library
// depends on another. I believe what you have to do is start
// with an arbitrary type library, and if that type library calls
// back on the ResolveRef() method, and if that type library is
// one you were planning to add later, you compile it
// immediately and pass the assembly back out of ResolveRef. I
// haven't tested this yet, but it's my best understanding of
// how it all works.
foreach (ReferenceBase reference in Parent.References) {
// we're only interested in imported type libraries
WrapperReferenceBase wrapper = reference as WrapperReferenceBase;
// avoid stack overflow causes by mutual dependencies
if (wrapper == null || !wrapper.IsCreated || wrapper.WrapperTool != "tlbimp") {
continue;
}
tlbImp.References.Includes.Add(wrapper.WrapperAssembly);
}
// increment indentation level
tlbImp.Project.Indent();
try {
// execute task
tlbImp.Execute();
} finally {
// restore indentation level
tlbImp.Project.Unindent();
}
}
protected override void ImportActiveXLibrary() {
AxImpTask axImp = new AxImpTask();
// parent is solution task
axImp.Parent = SolutionTask;
// inherit project from solution task
axImp.Project = SolutionTask.Project;
// inherit namespace manager from solution task
axImp.NamespaceManager = SolutionTask.NamespaceManager;
// inherit verbose setting from solution task
axImp.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
axImp.InitializeTaskConfiguration();
axImp.OcxFile = new FileInfo(GetTypeLibrary());
axImp.OutputFile = new FileInfo(WrapperAssembly);
string rcw = PrimaryInteropAssembly;
if (rcw == null) {
// if no primary interop assembly is provided for ActiveX control,
// trust the fact that VS.NET uses Interop..dll
// for the imported typelibrary
rcw = FileUtils.CombinePaths(Parent.ObjectDir.FullName,
"Interop." + TypeLibraryName + ".dll");
}
if (File.Exists(rcw)) {
axImp.RcwFile = new FileInfo(rcw);
}
// increment indentation level
axImp.Project.Indent();
try {
// execute task
axImp.Execute();
} finally {
// restore indentation level
axImp.Project.Unindent();
}
}
#endregion Private Instance Methods
#region Private Instance Fields
private readonly string _name = string.Empty;
private readonly string _wrapperTool;
private readonly string _wrapperAssembly;
private readonly string _primaryInteropAssembly;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/Resource.cs 0000644 0001750 0001750 00000033026 11757302274 017600 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
using System;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using NAnt.Core.Util;
using NAnt.DotNet.Tasks;
using NAnt.DotNet.Types;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
public class Resource {
#region Public Instance Constructors
public Resource(ManagedProjectBase project, FileInfo resourceSourceFile, string resourceSourceFileRelativePath, string dependentFile, SolutionTask solutionTask, GacCache gacCache) {
_project = project;
_resourceSourceFile = resourceSourceFile;
_resourceSourceFileRelativePath = resourceSourceFileRelativePath;
_dependentFile = dependentFile;
_solutionTask = solutionTask;
_culture = CompilerBase.GetResourceCulture(resourceSourceFile.FullName,
dependentFile);
}
#endregion Public Instance Constructors
#region Public Instance Properties
public CultureInfo Culture {
get { return _culture; }
}
///
/// Gets a representing the physical location
/// of the resource file.
///
public FileInfo InputFile {
get { return _resourceSourceFile; }
}
public ManagedProjectBase Project {
get { return _project; }
}
///
/// Gets a representing the logical location
/// of the resource file in the project.
///
///
/// When the resource file is not linked, this matches the
/// .
///
public FileInfo LogicalFile {
get {
return new FileInfo(FileUtils.CombinePaths(Path.GetDirectoryName(
Project.ProjectPath), _resourceSourceFileRelativePath));
}
}
///
/// Gets a value indicating whether the resource is in fact a ResX file.
///
///
/// if the resource is a ResX file; otherwise,
/// .
///
public bool IsResX {
get {
return InputFile.Extension.ToLower(CultureInfo.InvariantCulture) == ".resx";
}
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Compiles the resource file.
///
/// The solution configuration that is built.
///
/// A representing the compiled resource file.
///
public FileInfo Compile(Configuration solutionConfiguration) {
FileInfo compiledResourceFile = null;
switch (InputFile.Extension.ToLower(CultureInfo.InvariantCulture)) {
case ".resx":
compiledResourceFile = CompileResx(solutionConfiguration);
break;
case ".licx":
compiledResourceFile = CompileLicx(solutionConfiguration);
break;
default:
compiledResourceFile = CompileResource(solutionConfiguration);
break;
}
return compiledResourceFile;
}
///
/// Returns a representing the compiled resource
/// file.
///
/// The solution configuration that is built.
///
/// A representing the compiled resource file.
///
///
/// Calling this method does not force compilation of the resource file.
///
public FileInfo GetCompiledResourceFile(Configuration solutionConfiguration) {
string compiledResourceFile = null;
// obtain project configuration (corresponding with solution configuration)
ConfigurationSettings config = (ConfigurationSettings) Project.BuildConfigurations[solutionConfiguration];
switch (InputFile.Extension.ToLower(CultureInfo.InvariantCulture)) {
case ".resx":
compiledResourceFile = FileUtils.CombinePaths(config.ObjectDir.FullName,
GetManifestResourceName(solutionConfiguration));
break;
case ".licx":
compiledResourceFile = FileUtils.CombinePaths(config.ObjectDir.FullName,
Project.ProjectSettings.OutputFileName + ".licenses");
break;
default:
compiledResourceFile = InputFile.FullName;
break;
}
return new FileInfo(compiledResourceFile);
}
public string GetManifestResourceName(Configuration solutionConfiguration) {
// obtain project configuration (corresponding with solution configuration)
ConfigurationSettings projectConfig = (ConfigurationSettings) Project.BuildConfigurations[solutionConfiguration];
switch (Project.Type) {
case ProjectType.CSharp:
return GetManifestResourceNameCSharp(projectConfig, _dependentFile);
case ProjectType.VB:
return GetManifestResourceNameVB(projectConfig, _dependentFile);
case ProjectType.JSharp:
return GetManifestResourceNameJSharp(projectConfig, _dependentFile);
default:
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture,
"Unsupported project type '{0}'.", Project.Type));
}
}
#endregion Public Instance Methods
#region Private Instance Methods
private string GetManifestResourceNameCSharp(ConfigurationSettings configSetting, string dependentFile) {
// defer to the resource management code in CscTask
CscTask csc = new CscTask();
csc.Project = _solutionTask.Project;
csc.NamespaceManager = _solutionTask.NamespaceManager;
csc.OutputFile = new FileInfo(FileUtils.CombinePaths(configSetting.OutputDir.FullName,
Project.ProjectSettings.OutputFileName));
// set-up resource fileset
ResourceFileSet resources = new ResourceFileSet();
resources.Project = _solutionTask.Project;
resources.NamespaceManager = _solutionTask.NamespaceManager;
resources.Parent = csc;
resources.BaseDirectory = new DirectoryInfo(Path.GetDirectoryName(Project.ProjectPath));
resources.Prefix = Project.ProjectSettings.RootNamespace;
resources.DynamicPrefix = true;
// bug #1042917: use logical location of resource file to determine
// manifest resource name
return csc.GetManifestResourceName(resources, InputFile.FullName,
LogicalFile.FullName, dependentFile);
}
private string GetManifestResourceNameVB(ConfigurationSettings configSetting, string dependentFile) {
// defer to the resource management code in VbcTask
VbcTask vbc = new VbcTask();
vbc.Project = _solutionTask.Project;
vbc.NamespaceManager = _solutionTask.NamespaceManager;
vbc.OutputFile = new FileInfo(FileUtils.CombinePaths(configSetting.OutputDir.FullName,
Project.ProjectSettings.OutputFileName));
vbc.RootNamespace = Project.ProjectSettings.RootNamespace;
// set-up resource fileset
ResourceFileSet resources = new ResourceFileSet();
resources.Project = _solutionTask.Project;
resources.NamespaceManager = _solutionTask.NamespaceManager;
resources.Parent = vbc;
resources.BaseDirectory = new DirectoryInfo(Path.GetDirectoryName(Project.ProjectPath));
resources.Prefix = Project.ProjectSettings.RootNamespace;
resources.DynamicPrefix = false;
// bug #1042917: use logical location of resource file to determine
// manifest resource name
return vbc.GetManifestResourceName(resources, InputFile.FullName,
LogicalFile.FullName, dependentFile);
}
private string GetManifestResourceNameJSharp(ConfigurationSettings configSetting, string dependentFile) {
// defer to the resource management code in VjcTask
VjcTask vjc = new VjcTask();
vjc.Project = _solutionTask.Project;
vjc.NamespaceManager = _solutionTask.NamespaceManager;
vjc.OutputFile = new FileInfo(FileUtils.CombinePaths(configSetting.OutputDir.FullName,
Project.ProjectSettings.OutputFileName));
// set-up resource fileset
ResourceFileSet resources = new ResourceFileSet();
resources.Project = _solutionTask.Project;
resources.NamespaceManager = _solutionTask.NamespaceManager;
resources.Parent = vjc;
resources.BaseDirectory = new DirectoryInfo(Path.GetDirectoryName(
Project.ProjectPath));
resources.Prefix = Project.ProjectSettings.RootNamespace;
resources.DynamicPrefix = true;
// bug #1042917: use logical location of resource file to determine
// manifest resource name
return vjc.GetManifestResourceName(resources, InputFile.FullName,
LogicalFile.FullName, dependentFile);
}
private FileInfo CompileResource(Configuration solutionConfiguration) {
return GetCompiledResourceFile(solutionConfiguration);
}
private FileInfo CompileLicx(Configuration solutionConfiguration) {
// create instance of License task
LicenseTask lt = new LicenseTask();
// inherit project from solution task
lt.Project = _solutionTask.Project;
// inherit namespace manager from solution task
lt.NamespaceManager = _solutionTask.NamespaceManager;
// parent is solution task
lt.Parent = _solutionTask;
// inherit verbose setting from solution task
lt.Verbose = _solutionTask.Verbose;
// make sure framework specific information is set
lt.InitializeTaskConfiguration();
// set parent of child elements
lt.Assemblies.Parent = lt;
// inherit project from solution task from parent task
lt.Assemblies.Project = lt.Project;
// inherit namespace manager from parent task
lt.Assemblies.NamespaceManager = lt.NamespaceManager;
// set base directory for filesets
lt.Assemblies.BaseDirectory = new DirectoryInfo(Path.GetDirectoryName(Project.ProjectPath));
// set task properties
lt.InputFile = InputFile;
lt.OutputFile = GetCompiledResourceFile(solutionConfiguration);
// convert target to uppercase to match VS.NET
lt.Target = Path.GetFileName(Project.ProjectSettings.OutputFileName).
ToUpper(CultureInfo.InvariantCulture);
// inherit assembly references from project
foreach (ReferenceBase reference in Project.References) {
StringCollection assemblyReferences = reference.GetAssemblyReferences(
solutionConfiguration);
foreach (string assemblyFile in assemblyReferences) {
lt.Assemblies.Includes.Add(assemblyFile);
}
}
// increment indentation level
lt.Project.Indent();
try {
// execute task
lt.Execute();
} finally {
// restore indentation level
lt.Project.Unindent();
}
return lt.OutputFile;
}
private FileInfo CompileResx(Configuration solutionConfiguration) {
// for performance reasons, compilation of resx files is done in
// batch using the ResGen task in ManagedProjectBase
throw new InvalidOperationException();
}
#endregion Private Instance Methods
#region Private Instance Fields
private readonly CultureInfo _culture;
private readonly FileInfo _resourceSourceFile;
private readonly string _dependentFile;
private readonly string _resourceSourceFileRelativePath;
private readonly ManagedProjectBase _project;
private readonly SolutionTask _solutionTask;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/ReferenceBase.cs 0000644 0001750 0001750 00000022707 11757302274 020506 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
// Scott Ford (sford@RJKTECH.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
public abstract class ReferenceBase {
#region Protected Instance Constructors
protected ReferenceBase(ReferencesResolver referencesResolver, ProjectBase parent) {
_referencesResolver = referencesResolver;
_parent = parent;
}
#endregion Protected Instance Constructors
#region Public Instance Properties
///
/// Gets a value indicating whether the output file(s) of this reference
/// should be copied locally.
///
///
/// if the output file(s) of this reference
/// should be copied locally; otherwise, .
///
public abstract bool CopyLocal {
get;
}
///
/// Gets a value indicating whether this reference represents a system
/// assembly.
///
///
/// if this reference represents a system
/// assembly; otherwise, .
///
protected abstract bool IsSystem {
get;
}
public abstract string Name {
get;
}
#endregion Public Instance Properties
#region Protected Instance Properties
///
/// Gets the project in which the reference is defined.
///
protected ProjectBase Parent {
get { return _parent; }
}
protected SolutionTask SolutionTask {
get { return Parent.SolutionTask; }
}
protected ReferencesResolver ReferencesResolver {
get { return _referencesResolver; }
}
#endregion Protected Instance Properties
#region Public Instance Methods
///
/// Gets the output path of the reference, without taking the "copy local"
/// setting into consideration.
///
/// The solution configuration that is built.
///
/// The full output path of the reference.
///
public abstract string GetPrimaryOutputFile(Configuration solutionConfiguration);
///
/// Gets the complete set of output files of the reference for the
/// specified configuration.
///
/// The solution configuration that is built.
/// The set of output files to be updated.
///
/// The key of the case-insensitive is the
/// full path of the output file and the value is the path relative to
/// the output directory.
///
public abstract void GetOutputFiles(Configuration solutionConfiguration, Hashtable outputFiles);
///
/// Gets the complete set of assemblies that need to be referenced when
/// a project references this component.
///
/// The solution configuration that is built.
///
/// The complete set of assemblies that need to be referenced when a
/// project references this component.
///
public abstract StringCollection GetAssemblyReferences(Configuration solutionConfiguration);
///
/// Gets the timestamp of the reference.
///
/// The solution configuration that is built.
///
/// The timestamp of the reference.
///
public abstract DateTime GetTimestamp(Configuration solutionConfiguration);
///
/// Gets a value indicating whether the reference is managed for the
/// specified configuration.
///
/// The solution configuration that is built.
///
/// if the reference is managed for the
/// specified configuration; otherwise, .
///
public abstract bool IsManaged(Configuration solutionConfiguration);
#endregion Public Instance Methods
#region Protected Instance Methods
///
/// Returns the date and time the specified file was last written to.
///
/// The file for which to obtain write date and time information.
///
/// A structure set to the date and time that
/// the specified file was last written to, or
/// if the specified file does not
/// exist.
///
protected DateTime GetFileTimestamp(string fileName) {
if (!File.Exists(fileName)) {
return DateTime.MaxValue;
}
return File.GetLastWriteTime(fileName);
}
///
/// Logs a message with the given priority.
///
/// The message priority at which the specified message is to be logged.
/// The message to be logged.
///
/// The actual logging is delegated to the underlying task.
///
protected void Log(Level messageLevel, string message) {
SolutionTask.Log(messageLevel, message);
}
///
/// Logs a message with the given priority.
///
/// The message priority at which the specified message is to be logged.
/// The message to log, containing zero or more format items.
/// An array containing zero or more objects to format.
///
/// The actual logging is delegated to the underlying task.
///
protected void Log(Level messageLevel, string message, params object[] args) {
SolutionTask.Log(messageLevel, message, args);
}
#endregion Protected Instance Methods
#region Public Static Methods
public static void GetRelatedFiles(string file, Hashtable relatedFiles) {
// determine directory of specified file
string directory = Path.GetDirectoryName(file);
// check whether the directory of the specified file actually
// exists
if (StringUtils.ConvertEmptyToNull(directory) == null || !Directory.Exists(directory)) {
return;
}
// file itself should always be added
relatedFiles[file] = Path.GetFileName(file);
// pattern indicating what files to scan
string relatedFilesPattern = Path.GetFileName(Path.ChangeExtension(file, ".*"));
// iterate over each file matching the pattern
foreach (string relatedFile in Directory.GetFiles(Path.GetDirectoryName(file), relatedFilesPattern)) {
// ignore files that do not have same base filename as reference file
// eg. when reference file is MS.Runtime.dll, we do not want files
// named MS.Runtime.Interop.dll
if (string.Compare(Path.GetFileNameWithoutExtension(relatedFile), Path.GetFileNameWithoutExtension(file), true, CultureInfo.InvariantCulture) != 0) {
continue;
}
// ignore any other the garbage files created
string fileExtension = Path.GetExtension(relatedFile).ToLower(CultureInfo.InvariantCulture);
if (fileExtension != ".dll" && fileExtension != ".xml" && fileExtension != ".pdb" && fileExtension != ".mdb") {
continue;
}
relatedFiles[relatedFile] = Path.GetFileName(relatedFile);
}
}
#endregion Public Static Methods
#region Private Instance Fields
private ProjectBase _parent;
private ReferencesResolver _referencesResolver;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/ProjectFactory.cs 0000644 0001750 0001750 00000023133 11757302274 020745 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Dmitry Jemerov
using System;
using System.Xml;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Text;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Extensibility;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
///
/// Factory class for VS.NET projects.
///
internal sealed class ProjectFactory {
#region Private Instance Constructor
///
/// Initializes a new instance of the
/// class.
///
private ProjectFactory(SolutionTask solutionTask) {
_cachedProjects = CollectionsUtil.CreateCaseInsensitiveHashtable();
_cachedProjectGuids = CollectionsUtil.CreateCaseInsensitiveHashtable();
_cachedProjectXml = CollectionsUtil.CreateCaseInsensitiveHashtable();
}
#endregion Private Instance Constructor
#region Public Static Methods
public static ProjectFactory Create(SolutionTask solutionTask) {
return new ProjectFactory(solutionTask);
}
public static bool IsUrl(string fileName) {
if (fileName.StartsWith(Uri.UriSchemeFile) || fileName.StartsWith(Uri.UriSchemeHttp) || fileName.StartsWith(Uri.UriSchemeHttps)) {
return true;
}
return false;
}
#endregion Public Static Methods
#region Public Instance Methods
public XmlDocument LoadProjectXml(string path) {
if (!_cachedProjectXml.Contains(path)) {
XmlDocument doc = new XmlDocument();
if (!ProjectFactory.IsUrl(path)) {
using (StreamReader sr = new StreamReader(path, Encoding.Default, true)) {
doc.Load(sr);
}
} else {
Uri uri = new Uri(path);
if (uri.Scheme == Uri.UriSchemeFile) {
using (StreamReader sr = new StreamReader(uri.LocalPath, Encoding.Default, true)) {
doc.Load(sr);
}
} else {
doc.LoadXml(WebDavClient.GetFileContentsStatic(path));
}
}
_cachedProjectXml[path] = doc;
}
return (XmlDocument) _cachedProjectXml[path];
}
public ProjectBase LoadProject(SolutionBase solution, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver referencesResolver, DirectoryInfo outputDir, string path) {
// check if this a new project
if (!_cachedProjects.Contains(path)) {
ProjectBase project = CreateProject(solution, solutionTask,
tfc, gacCache, referencesResolver, outputDir, path);
_cachedProjects[path] = project;
}
return (ProjectBase) _cachedProjects[path];
}
public string LoadGuid(string fileName) {
// check if a project with specified file is already cached
if (_cachedProjects.ContainsKey(fileName)) {
// return the guid of the cached project
return ((ProjectBase) _cachedProjects[fileName]).Guid;
}
string projectFileName = ProjectFactory.GetProjectFileName(fileName);
string projectExt = Path.GetExtension(projectFileName).ToLower(
CultureInfo.InvariantCulture);
// holds the XML definition of the project
XmlElement xmlDefinition;
try {
XmlDocument doc = LoadProjectXml(fileName);
xmlDefinition = doc.DocumentElement;
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Error loading project '{0}'.", fileName), Location.UnknownLocation,
ex);
}
IProjectBuildProvider provider = FindProvider(projectExt, xmlDefinition);
if (provider != null) {
_cachedProjectGuids[fileName] = provider.LoadGuid(xmlDefinition);
}
// return project GUID from cache
return (string) _cachedProjectGuids[fileName];
}
public void RegisterProvider(IProjectBuildProvider provider) {
_projectprovs.Add(provider);
}
#endregion Public Instance Methods
#region Private Instance Methods
private ProjectBase CreateProject(SolutionBase solution, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver referencesResolver, DirectoryInfo outputDir, string projectPath) {
// determine the filename of the project
string projectFileName = ProjectFactory.GetProjectFileName(projectPath);
// determine the extension of the project file
string projectExt = Path.GetExtension(projectFileName).ToLower(
CultureInfo.InvariantCulture);
// fast-skip setup projects since the project files is not XML-based
if (projectExt == ".vdproj") {
return null;
}
// holds the XML definition of the project
XmlElement xmlDefinition;
try {
XmlDocument doc = LoadProjectXml(projectPath);
xmlDefinition = doc.DocumentElement;
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Error loading project '{0}'.", projectPath), Location.UnknownLocation,
ex);
}
IProjectBuildProvider provider = FindProvider(projectExt, xmlDefinition);
if (provider != null) {
return provider.GetInstance(solution, projectPath, xmlDefinition,
solutionTask, tfc, gacCache, referencesResolver, outputDir);
}
// either the project file is invalid or we don't support it
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Project '{0}' is invalid or not supported (at this time).",
projectPath), Location.UnknownLocation);
}
private IProjectBuildProvider FindProvider(string projectExt, XmlElement xmlDefinition) {
int max = 0;
IProjectBuildProvider res = null;
foreach (IProjectBuildProvider provider in _projectprovs) {
int pri = provider.IsSupported(projectExt, xmlDefinition);
if (pri > max) {
max = pri;
res = provider;
}
}
return res;
}
#endregion Private Instance Methods
#region Private Static Methods
private static string GetProjectFileName(string fileName) {
string projectPath = null;
if (ProjectFactory.IsUrl(fileName)) {
// construct uri for project path
Uri projectUri = new Uri(fileName);
// get last segment of the uri (which should be the
// project file itself)
projectPath = projectUri.LocalPath;
} else {
projectPath = fileName;
}
// return filename part
return Path.GetFileName(projectPath);
}
#endregion Private Static Methods
#region Private Instance Fields
///
/// Holds a case-insensitive list of cached projects.
///
///
/// The key of the is the path of the project
/// file (for web projects this can be a URL) and the value is a
/// instance.
///
private readonly Hashtable _cachedProjects;
///
/// Holds a case-insensitive list of cached project GUIDs.
///
///
/// The key of the is the path of the project
/// file (for web projects this can be a URL) and the value is the GUID
/// of the project.
///
private readonly Hashtable _cachedProjectGuids;
///
/// Holds a case-insensitive list of cached project GUIDs.
///
///
/// The key of the is the path of the project
/// file (for web projects this can be a URL) and the value is the Xml
/// of the project.
///
private readonly Hashtable _cachedProjectXml;
private readonly ArrayList _projectprovs = new ArrayList();
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/Extensibility/ 0000755 0001750 0001750 00000000000 11757310030 020277 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.VSNet/Extensibility/IProjectBuildProvider.cs 0000644 0001750 0001750 00000003536 11757302274 025062 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Martin Aliger (martin_aliger@myrealbox.com)
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Extensibility;
using NAnt.Core.Util;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet.Extensibility {
public interface IProjectBuildProvider : IPlugin {
///
/// Returns a number representing how much this file fits this project type.
///
///
///
///
///
/// This enables the override in other providers. Do not return big numbers, mainly when compring only on filename.
///
int IsSupported(string projectExt, XmlElement xmlDefinition);
ProjectBase GetInstance(SolutionBase solution, string projectPath, XmlElement xmlDefinition, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver, DirectoryInfo outputDir);
string LoadGuid(XmlElement xmlDefinition);
}
}
nant-0.92-rc1/src/NAnt.VSNet/Extensibility/ISolutionBuildProvider.cs 0000644 0001750 0001750 00000002424 11757302274 025263 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Martin Aliger (martin_aliger@myrealbox.com)
using System;
using System.CodeDom.Compiler;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Extensibility;
using NAnt.Core.Util;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet.Extensibility {
public interface ISolutionBuildProvider : IPlugin {
int IsSupported(string fileContents);
SolutionBase GetInstance(string solutionContent, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver);
}
}
nant-0.92-rc1/src/NAnt.VSNet/CSharpProject.cs 0000644 0001750 0001750 00000020062 11757302274 020514 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.CodeDom.Compiler;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
public class CSharpProject : ManagedProjectBase {
#region Public Instance Constructors
public CSharpProject(SolutionBase solution, string projectPath, XmlElement xmlDefinition, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver, DirectoryInfo outputDir) : base(solution, projectPath, xmlDefinition, solutionTask, tfc, gacCache, refResolver, outputDir) {
}
#endregion Public Instance Constructors
#region Override implementation of ProjectBase
///
/// Gets the type of the project.
///
///
/// The type of the project.
///
public override ProjectType Type {
get { return ProjectType.CSharp; }
}
///
/// Verifies whether the specified XML fragment represents a valid project
/// that is supported by this .
///
/// XML fragment representing the project file.
///
/// The XML fragment is not supported by this .
/// -or-
/// The XML fragment does not represent a valid project (for this ).
///
protected override void VerifyProjectXml(XmlElement docElement) {
if (!IsSupported(docElement)) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Project '{0}' is not a valid C# project.", ProjectPath),
Location.UnknownLocation);
}
}
///
/// Returns the Visual Studio product version of the specified project
/// XML fragment.
///
/// The document element of the project.
///
/// The Visual Studio product version of the specified project XML
/// fragment.
///
///
/// The product version could not be determined.
/// -or-
/// The product version is not supported.
///
protected override ProductVersion DetermineProductVersion(XmlElement docElement) {
return GetProductVersion(docElement.SelectSingleNode("./CSHARP"));
}
///
/// Returns a for launching the compiler
/// for this project.
///
/// The configuration to build.
/// The response file for the compiler.
///
/// A for launching the compiler for
/// this project.
///
protected override ProcessStartInfo GetProcessStartInfo(ConfigurationBase config, string responseFile) {
ProcessStartInfo psi = new ProcessStartInfo(FileUtils.CombinePaths(SolutionTask.
Project.TargetFramework.FrameworkDirectory.FullName, "csc.exe"),
"/noconfig @\"" + responseFile + "\"");
// to resolve the path to the file specified in the AssemblyKeyFile
// attribute, the command line compilers try to resolve that relative
// path using the output directory and the current directory
//
// VS.NET compiles assembly to the intermediate output directory and
// uses the solution directory as current directory
if (SolutionTask.SolutionFile != null) {
psi.WorkingDirectory = Path.GetDirectoryName(SolutionTask.SolutionFile.FullName);
} else {
psi.WorkingDirectory = ProjectDirectory.FullName;
}
return psi;
}
#endregion Override implementation of ProjectBase
#region Override implementation of ManagedProjectBase
///
/// Gets the default file extension of sources for this project.
///
///
/// For C# projects, the default file extension is ".cs".
///
protected override string FileExtension {
get { return ".cs"; }
}
///
/// Returns the project location from the specified project XML fragment.
///
/// XML fragment representing the project file.
///
/// The project location of the specified project XML file.
///
///
/// The project location could not be determined.
/// -or-
/// The project location is invalid.
///
protected override ProjectLocation DetermineProjectLocation(XmlElement docElement) {
return GetProjectLocation(docElement.SelectSingleNode("./CSHARP"));
}
#endregion Override implementation of ManagedProjectBase
#region Public Static Methods
///
/// Returns a value indicating whether the project represented by the
/// specified XML fragment is supported by .
///
/// XML fragment representing the project to check.
///
/// if supports
/// the specified project; otherwise, .
///
///
///
/// A project is identified as as C# project, if the XML fragment at
/// least has the following information:
///
///
///
///
/// ...
///
///
/// ]]>
///
///
public static bool IsSupported(XmlElement docElement) {
if (docElement == null) {
return false;
}
if (docElement.Name != "VisualStudioProject") {
return false;
}
XmlNode projectNode = docElement.SelectSingleNode("./CSHARP");
if (projectNode == null) {
return false;
}
try {
GetProductVersion(projectNode);
// no need to perform version check here as this is done in
// GetProductVersion
} catch {
// product version could not be determined or is not supported
return false;
}
return true;
}
#endregion Public Static Methods
}
}
nant-0.92-rc1/src/NAnt.VSNet/WrapperReferenceBase.cs 0000644 0001750 0001750 00000050134 11757302274 022042 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
// Scott Ford (sford@RJKTECH.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Runtime.InteropServices;
#if NET_2_0
using System.Runtime.InteropServices.ComTypes;
#endif
using System.Xml;
using Microsoft.Win32;
using NAnt.Core;
using NAnt.Core.Tasks;
using NAnt.Core.Util;
using NAnt.Core.Types;
using NAnt.Win32.Tasks;
namespace NAnt.VSNet {
public abstract class WrapperReferenceBase : FileReferenceBase {
#region Protected Instance Constructors
protected WrapperReferenceBase(XmlElement xmlDefinition, ReferencesResolver referencesResolver, ProjectBase parent, GacCache gacCache) : base(xmlDefinition, referencesResolver, parent, gacCache) {
}
#endregion Protected Instance Constructors
#region Override implementation of ReferenceBase
///
/// Gets a value indicating whether the output file(s) of this reference
/// should be copied locally.
///
///
/// if the reference wraps a Primary Interop
/// Assembly; otherwise, .
///
public override bool CopyLocal {
get { return (WrapperTool != "primary"); }
}
///
/// Gets a value indicating whether this reference represents a system
/// assembly.
///
///
/// as none of the system assemblies are wrappers
/// or Primary Interop Assemblies anyway.
///
protected override bool IsSystem {
get { return false; }
}
///
/// Gets the path of the reference, without taking the "copy local"
/// setting into consideration.
///
/// The solution configuration that is built.
///
/// The output path of the reference.
///
public override string GetPrimaryOutputFile(Configuration solutionConfiguration) {
return WrapperAssembly;
}
///
/// Gets the complete set of output files for the referenced project.
///
/// The solution configuration that is built.
/// The set of output files to be updated.
///
/// The key of the case-insensitive is the
/// full path of the output file and the value is the path relative to
/// the output directory.
///
public override void GetOutputFiles(Configuration solutionConfiguration, Hashtable outputFiles) {
// obtain project configuration (corresponding with solution configuration)
ConfigurationBase config = Parent.BuildConfigurations[solutionConfiguration];
base.GetAssemblyOutputFiles(CreateWrapper(config), outputFiles);
}
///
/// Gets the complete set of assemblies that need to be referenced when
/// a project references this component.
///
/// The solution configuration that is built.
///
/// The complete set of assemblies that need to be referenced when a
/// project references this component.
///
public override StringCollection GetAssemblyReferences(Configuration solutionConfiguration) {
// obtain project configuration (corresponding with solution configuration)
ConfigurationBase config = Parent.BuildConfigurations[solutionConfiguration];
// ensure wrapper is actually created
string assemblyFile = CreateWrapper(config);
if (!File.Exists(assemblyFile)) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Couldn't find assembly \"{0}\", referenced by project \"{1}\".",
assemblyFile, Parent.Name), Location.UnknownLocation);
}
// add referenced assembly to list of reference assemblies
StringCollection assemblyReferences = new StringCollection();
assemblyReferences.Add(assemblyFile);
return assemblyReferences;
}
///
/// Gets the timestamp of the reference.
///
/// The solution configuration that is built.
///
/// The timestamp of the reference.
///
public override DateTime GetTimestamp(Configuration solutionConfiguration) {
return GetFileTimestamp(WrapperAssembly);
}
#endregion Override implementation of ReferenceBase
#region Public Instance Properties
///
/// Gets the name of the tool that should be used to create the
/// .
///
///
/// The name of the tool that should be used to create the
/// .
///
public abstract string WrapperTool {
get;
}
///
/// Gets the path of the wrapper assembly.
///
///
/// The path of the wrapper assembly.
///
///
/// The wrapper assembly is stored in the object directory of the
/// project.
///
public abstract string WrapperAssembly {
get;
}
///
/// Gets a value indicating whether the wrapper assembly has already been
/// created.
///
public bool IsCreated {
get { return _isCreated; }
}
#endregion Public Instance Properties
#region Protected Instance Properties
///
/// Gets the path of the Primary Interop Assembly.
///
///
/// The path of the Primary Interop Assembly, or
/// if not available.
///
protected abstract string PrimaryInteropAssembly {
get;
}
///
/// Gets the hex version of the type library as defined in the definition
/// of the reference.
///
///
/// The hex version of the type library.
///
protected abstract string TypeLibVersion {
get;
}
///
/// Gets the GUID of the type library as defined in the definition
/// of the reference.
///
///
/// The GUID of the type library.
///
protected abstract string TypeLibGuid {
get;
}
///
/// Gets the locale of the type library in hex notation.
///
///
/// The locale of the type library.
///
protected abstract string TypeLibLocale {
get;
}
///
/// Gets the name of the type library.
///
///
/// The name of the type library.
///
protected virtual string TypeLibraryName {
get {
return GetTypeLibraryName(GetTypeLibrary());
}
}
#endregion Protected Instance Properties
#region Protected Instance Methods
protected abstract void ImportTypeLibrary();
protected abstract void ImportActiveXLibrary();
protected string ResolveWrapperAssembly() {
string wrapperAssembly = null;
switch (WrapperTool) {
case "primary":
wrapperAssembly = PrimaryInteropAssembly;
if (wrapperAssembly == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Couldn't find Primary Interop Assembly \"{0}\","
+ " referenced by project \"{1}\".", Name, Parent.Name),
Location.UnknownLocation);
}
return wrapperAssembly;
case "aximp":
wrapperAssembly = "AxInterop." + TypeLibraryName + ".dll";
break;
default:
wrapperAssembly = "Interop." + TypeLibraryName + ".dll";
break;
}
// resolve to full path
return FileUtils.CombinePaths(Parent.ObjectDir.FullName,
wrapperAssembly);
}
protected string GetPrimaryInteropAssembly() {
string typeLibVersionKey = string.Format(CultureInfo.InvariantCulture,
@"TYPELIB\{0}\{1}", TypeLibGuid, TypeLibVersion);
string assemblyFile = null;
using (RegistryKey registryKey = Registry.ClassesRoot.OpenSubKey(typeLibVersionKey)) {
if (registryKey != null && registryKey.GetValue("PrimaryInteropAssemblyName") != null) {
string primaryInteropAssemblyName = (string) registryKey.GetValue("PrimaryInteropAssemblyName");
try {
// get filename of primary interop assembly
assemblyFile = ReferencesResolver.GetAssemblyFileName(
primaryInteropAssemblyName);
} catch (Exception ex) {
// only have build fail if we're actually dealing with a
// reference to a primary interop assembly
//
// certain tools (such as Office) register the name of
// the primary interop assembly of the typelib, but the
// actual primary interop assembly is not always installed
if (WrapperTool == "primary") {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Primary Interop Assembly \"{0}\", referenced by project"
+ " \"{1}\", could not be loaded.", primaryInteropAssemblyName,
Parent.Name), Location.UnknownLocation, ex);
}
}
}
}
return assemblyFile;
}
protected string GetTypeLibrary() {
string typeLibKey = string.Format(CultureInfo.InvariantCulture,
@"TYPELIB\{0}\{1}\{2}\win32", TypeLibGuid, TypeLibVersion,
TypeLibLocale);
using (RegistryKey registryKey = Registry.ClassesRoot.OpenSubKey(typeLibKey)) {
// TODO: if there's no direct match, then use a type library
// with the same major version, and the highest minor version
// TODO: check if the library identifier matches the one of the
// reference
if (registryKey == null) {
throw CreateTypeLibraryNotRegisteredException();
}
string typeLibValue = (string) registryKey.GetValue(null);
if (String.IsNullOrEmpty(typeLibValue)) {
throw CreateInvalidTypeLibraryRegistrationException();
}
// extract path to type library from reg value
string typeLibPath = TlbImpTask.ExtractTypeLibPath(typeLibValue);
// check if the typelib actually exists
if (!File.Exists(typeLibPath)) {
throw CreateTypeLibraryPathDoesNotExistException(typeLibPath);
}
return typeLibValue;
}
}
protected string GetTypeLibraryName(string typeLibraryPath) {
Object typeLib;
try {
LoadTypeLibEx(typeLibraryPath, 0, out typeLib);
} catch (COMException ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Type library \"{0}\" could not be loaded.", typeLibraryPath),
Location.UnknownLocation, ex);
}
if (typeLib == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Type library \"{0}\" could not be loaded.", typeLibraryPath),
Location.UnknownLocation);
}
#if NET_2_0
return Marshal.GetTypeLibName((ITypeLib) typeLib);
#else
return Marshal.GetTypeLibName((UCOMITypeLib) typeLib);
#endif
}
#endregion Protected Instance Methods
#region Private Instance Methods
private string CreateWrapper(ConfigurationBase config) {
// if wrapper assembly was created during the current build, then
// there's no need to create it again
if (IsCreated) {
return WrapperAssembly;
}
// synchronize build and output directory
Sync(config);
switch (WrapperTool) {
case "primary":
// nothing to do for Primary Interop Assembly
break;
case "tlbimp":
if (PrimaryInteropAssembly != null) {
// if tlbimp is defined as import tool, but a primary
// interop assembly is available, then output a
// warning
Log(Level.Warning, "The component \"{0}\", referenced by"
+ " project \"{1}\" has an updated custom wrapper"
+ " available.", Name, Parent.Name);
}
ImportTypeLibrary();
break;
case "aximp":
ImportActiveXLibrary();
break;
default:
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Wrapper tool \"{0}\" for reference \"{1}\" in project"
+ " \"{2}\" is not supported.", WrapperTool, Name,
Parent.Name), Location.UnknownLocation);
}
// mark wrapper as completed
_isCreated = true;
return WrapperAssembly;
}
///
/// Removes wrapper assembly from build directory, if wrapper assembly
/// no longer exists in output directory or is not in sync with build
/// directory, to force rebuild.
///
/// The project configuration.
private void Sync(ConfigurationBase config) {
if (!CopyLocal || !File.Exists(WrapperAssembly)) {
// nothing to synchronize
return;
}
// determine path where wrapper assembly should be deployed to
string outputFile = FileUtils.CombinePaths(config.OutputDir.FullName,
Path.GetFileName(WrapperAssembly));
// determine last modification date/time of built wrapper assembly
DateTime wrapperModTime = File.GetLastWriteTime(WrapperAssembly);
// rebuild wrapper assembly if output assembly is more recent,
// or have been removed (by the user) to force a rebuild
if (FileSet.FindMoreRecentLastWriteTime(outputFile, wrapperModTime) != null) {
// remove wrapper assembly to ensure a rebuild is performed
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = SolutionTask.Project;
deleteTask.Parent = SolutionTask;
deleteTask.InitializeTaskConfiguration();
deleteTask.File = new FileInfo(WrapperAssembly);
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
}
private BuildException CreateTypeLibraryNotRegisteredException() {
string msg = null;
if (String.IsNullOrEmpty(Name)) {
msg = string.Format(CultureInfo.InvariantCulture, "Couldn't" +
" find type library \"{0}\" with version {1}, referenced" +
" by project \"{2}\".", TypeLibGuid, TypeLibVersion,
Parent.Name);
} else {
msg = string.Format(CultureInfo.InvariantCulture, "Couldn't" +
" find type library \"{0}\" ({1} with version {2}), referenced" +
" by project \"{3}\".", Name, TypeLibGuid, TypeLibVersion,
Parent.Name);
}
return new BuildException(msg, Location.UnknownLocation);
}
private BuildException CreateInvalidTypeLibraryRegistrationException() {
string msg = null;
if (String.IsNullOrEmpty(Name)) {
msg = string.Format(CultureInfo.InvariantCulture, "Couldn't" +
" find path of type library \"{0}\" with version {1}, referenced" +
" by project \"{2}\". Ensure the type library is registered" +
"correctly.", TypeLibGuid, TypeLibVersion, Parent.Name);
} else {
msg = string.Format(CultureInfo.InvariantCulture, "Couldn't" +
" find path of type library \"{0}\" ({1} with version {2})," +
" referenced by project \"{3}\". Ensure the type library is" +
" registered correctly.", Name, TypeLibGuid, TypeLibVersion,
Parent.Name);
}
return new BuildException(msg, Location.UnknownLocation);
}
private BuildException CreateTypeLibraryPathDoesNotExistException(string typeLibraryPath) {
string msg = null;
if (String.IsNullOrEmpty(Name)) {
msg = string.Format(CultureInfo.InvariantCulture, "Type library" +
" \"{0}\" with version {1}, referenced by project \"{2}\"," +
" no longer exists at registered path \"{3}\".", TypeLibGuid,
TypeLibVersion, Parent.Name, typeLibraryPath);
} else {
msg = string.Format(CultureInfo.InvariantCulture, "Type library" +
" \"{0}\" ({1} with version {2}), referenced by project \"{3}\"," +
" no longer exists at registered path \"{4}\".", Name,
TypeLibGuid, TypeLibVersion, Parent.Name, typeLibraryPath);
}
return new BuildException(msg, Location.UnknownLocation);
}
#endregion Private Instance Methods
#region Private Static Methods
[DllImport( "oleaut32.dll", CharSet=CharSet.Unicode, PreserveSig=false)]
private static extern void LoadTypeLibEx(string strTypeLibName, int regKind,
[MarshalAs(UnmanagedType.Interface)] out Object typeLib);
#endregion Private Static Methods
#region Private Instance Fields
private bool _isCreated;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/VCProjectProvider.cs 0000644 0001750 0001750 00000003730 11757302274 021362 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Martin Aliger (martin_aliger@myrealbox.com)
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Extensibility;
using NAnt.Core.Util;
using NAnt.VSNet.Extensibility;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
internal class VCProjectProvider : IProjectBuildProvider {
#region Implementation of IProjectBuildProvider
public int IsSupported(string projectExt, XmlElement xmlDefinition) {
if (projectExt == ".vcproj")
return 5;
if (VcProject.IsSupported(xmlDefinition))
return 10;
return 0;
}
public ProjectBase GetInstance(SolutionBase solution, string projectPath, XmlElement xmlDefinition, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver, DirectoryInfo outputDir) {
return new VcProject(solution, projectPath, xmlDefinition, solutionTask, tfc, gacCache, refResolver, outputDir);
}
public string LoadGuid(XmlElement xmlDefinition) {
return VcProject.LoadGuid(xmlDefinition);
}
#endregion Implementation of IProjectBuildProvider
}
}
nant-0.92-rc1/src/NAnt.VSNet/ProjectReferenceBase.cs 0000644 0001750 0001750 00000021411 11757302274 022024 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
// Scott Ford (sford@RJKTECH.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
namespace NAnt.VSNet {
public abstract class ProjectReferenceBase : ReferenceBase {
#region Protected Instance Constructors
protected ProjectReferenceBase(ReferencesResolver referencesResolver, ProjectBase parent) : base(referencesResolver, parent) {
}
#endregion Protected Instance Constructors
#region Protected Instance Properties
protected abstract bool IsPrivate {
get;
}
protected abstract bool IsPrivateSpecified {
get;
}
#endregion Protected Instance Properties
#region Override implementation of ReferenceBase
///
/// Gets a value indicating whether the output file(s) of this reference
/// should be copied locally.
///
///
/// if the output file(s) of this reference
/// should be copied locally; otherwise, .
///
public override bool CopyLocal {
get { return IsPrivateSpecified ? IsPrivate : true; }
}
public override string Name {
get { return Project.Name; }
}
///
/// Gets a value indicating whether this reference represents a system
/// assembly.
///
///
/// as a project by itself can never be a
/// system assembly.
///
protected override bool IsSystem {
get { return false; }
}
///
/// Gets the output path of the reference, without taking the "copy local"
/// setting into consideration.
///
/// The solution configuration that is built.
///
/// The output path of the reference.
///
public override string GetPrimaryOutputFile(Configuration solutionConfiguration) {
return Project.GetOutputPath(solutionConfiguration);
}
///
/// Gets the complete set of output files for the referenced project.
///
/// The solution configuration that is built.
/// The set of output files to be updated.
///
/// The complete set of output files for the referenced project.
///
///
/// The key of the case-insensitive is the
/// full path of the output file and the value is the path relative to
/// the output directory.
///
public override void GetOutputFiles(Configuration solutionConfiguration, Hashtable outputFiles) {
Project.GetOutputFiles(solutionConfiguration, outputFiles);
}
///
/// Gets the complete set of assemblies that need to be referenced when
/// a project references this project.
///
/// The solution configuration that is built.
///
/// The complete set of assemblies that need to be referenced when a
/// project references this project.
///
///
///
/// Apparently, there's some hack in VB.NET that allows a type to be used
/// that derives from a type in an assembly that is not referenced by the
/// project.
///
///
/// When building from the command line (using vbc), the following error
/// is reported "error BC30007: Reference required to assembly 'X'
/// containing the base class 'X'. Add one to your project".
///
///
/// Somehow VB.NET can workaround this issue, without actually adding a
/// reference to that assembly. I verified this with both VS.NET 2003 and
/// VS.NET 2005.
///
///
/// For now, we have no other option than to return all assembly
/// references of the referenced project if the parent is a VB.NET
/// project.
///
///
public override StringCollection GetAssemblyReferences(Configuration solutionConfiguration) {
StringCollection assemblyReferences = null;
// check if parent is a VB.NET project
if (typeof(VBProject).IsAssignableFrom(Parent.GetType())) {
assemblyReferences = Project.GetAssemblyReferences(solutionConfiguration);
} else {
assemblyReferences = new StringCollection();
}
ConfigurationBase projectConfig = Project.GetConfiguration(
solutionConfiguration);
// check if project is actual configured to be built
if (projectConfig != null) {
string projectOutputFile = projectConfig.BuildPath;
// check if project has output file
if (projectOutputFile != null) {
if (File.Exists(projectOutputFile)) {
// add primary output to list of reference assemblies
assemblyReferences.Add(projectOutputFile);
}
}
}
// return assembly references
return assemblyReferences;
}
///
/// Gets the timestamp of the reference.
///
/// The solution configuration that is built.
///
/// The timestamp of the reference.
///
public override DateTime GetTimestamp(Configuration solutionConfiguration) {
string projectOutputFile = Project.GetOutputPath(solutionConfiguration);
if (projectOutputFile != null) {
return GetFileTimestamp(projectOutputFile);
} else {
// if project has no output file, then we assume that it creates
// a file through another way (eg. by launching an application
// that creates an assembly)
return DateTime.MaxValue;
}
}
#endregion Override implementation of ReferenceBase
#region Public Instance Properties
public abstract ProjectBase Project {
get;
}
#endregion Public Instance Properties
#region Protected Instance Methods
protected ProjectBase LoadProject(SolutionBase solution, TempFileCollection tfc, GacCache gacCache, DirectoryInfo outputDir, string projectFile) {
if (ProjectStack.Contains(projectFile)) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Circular reference to \"{0}\" detected in project \"{1}\".",
Path.GetFileNameWithoutExtension(projectFile), Parent.Name),
Location.UnknownLocation);
}
try {
ProjectStack.Push(projectFile);
Log(Level.Verbose, "Loading referenced project '{0}'.", projectFile);
return SolutionTask.ProjectFactory.LoadProject(solution,
SolutionTask, tfc, gacCache, ReferencesResolver, outputDir,
projectFile);
} finally {
ProjectStack.Pop();
}
}
#endregion Protected Instance Methods
#region Private Static Fields
private static readonly Stack ProjectStack = new Stack();
#endregion Private Static Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/ConfigurationDictionary.cs 0000644 0001750 0001750 00000017251 11757302274 022650 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2008 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net.be)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
namespace NAnt.VSNet {
public sealed class ConfigurationDictionary : IDictionary, ICollection, IEnumerable {
#region Private Instance Fields
private readonly Hashtable _innerHash;
#endregion Private Instance Fields
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public ConfigurationDictionary() {
_innerHash = CollectionsUtil.CreateCaseInsensitiveHashtable();
}
#endregion Public Instance Constructors
#region Internal Instance Properties
internal Hashtable InnerHash {
get { return _innerHash; }
}
#endregion Internal Instance Properties
#region Implementation of IDictionary
public ConfigurationDictionaryEnumerator GetEnumerator() {
return new ConfigurationDictionaryEnumerator(this);
}
IDictionaryEnumerator IDictionary.GetEnumerator() {
return GetEnumerator ();
}
IEnumerator IEnumerable.GetEnumerator() {
return GetEnumerator();
}
public void Remove(Configuration configuration) {
_innerHash.Remove(configuration);
}
void IDictionary.Remove(object key) {
Remove((Configuration) key);
}
public bool Contains(Configuration key) {
return _innerHash.Contains(key);
}
bool IDictionary.Contains(object key) {
return Contains((Configuration) key);
}
public void Clear() {
_innerHash.Clear();
}
public void Add(Configuration key, ConfigurationBase value) {
_innerHash.Add (key, value);
}
void IDictionary.Add(object key, object value) {
Add((Configuration) key, (ConfigurationBase) value);
}
public bool IsReadOnly {
get { return _innerHash.IsReadOnly; }
}
public ConfigurationBase this[Configuration key] {
get {
ConfigurationBase foundConfig = (ConfigurationBase) _innerHash[key];
if (foundConfig == null) {
// if no exact match for build configuration and platform
// was found, then only match on the name of the configuration
//
// we need this for two reasons:
// 1) when no platform is specified on the task,
// but we still want to match project configurations with
// a platform.
// 2) when a platform is specified on the task,
// but we want to match any given project configuration
// with the same configuration name.
foreach (DictionaryEntry de in _innerHash) {
Configuration config = (Configuration) de.Key;
if (string.Compare (config.Name, key.Name, true, CultureInfo.InvariantCulture) == 0) {
foundConfig = (ConfigurationBase) de.Value;
break;
}
}
}
return foundConfig;
}
set { _innerHash[key] = value; }
}
object IDictionary.this[object key] {
get { return this[(Configuration) key]; }
set { this[(Configuration) key] = (ConfigurationBase) value; }
}
public ICollection Values {
get { return _innerHash.Values; }
}
public ICollection Keys {
get { return _innerHash.Keys; }
}
public bool IsFixedSize {
get { return _innerHash.IsFixedSize; }
}
#endregion Implementation of IDictionary
#region Implementation of ICollection
void ICollection.CopyTo(Array array, int index) {
_innerHash.CopyTo(array, index);
}
public bool IsSynchronized {
get { return _innerHash.IsSynchronized; }
}
public int Count {
get { return _innerHash.Count; }
}
public object SyncRoot {
get { return _innerHash.SyncRoot; }
}
#endregion Implementation of ICollection
#region HashTable Methods
public bool ContainsKey (Configuration key) {
return _innerHash.ContainsKey(key);
}
public bool ContainsValue(ConfigurationBase value) {
return _innerHash.ContainsValue(value);
}
#endregion HashTable Methods
}
public class ConfigurationDictionaryEnumerator : IDictionaryEnumerator {
#region Private Instance Fields
private readonly IDictionaryEnumerator _innerEnumerator;
#endregion Private Instance Fields
#region Internal Instance Constructors
internal ConfigurationDictionaryEnumerator(ConfigurationDictionary enumerable) {
_innerEnumerator = enumerable.InnerHash.GetEnumerator();
}
#endregion Internal Instance Constructors
#region Implementation of IDictionaryEnumerator
public Configuration Key {
get { return (Configuration) _innerEnumerator.Key; }
}
object IDictionaryEnumerator.Key {
get { return Key; }
}
public ConfigurationBase Value {
get { return (ConfigurationBase) _innerEnumerator.Value; }
}
object IDictionaryEnumerator.Value {
get { return Value; }
}
public DictionaryEntry Entry {
get { return new DictionaryEntry (Key, Value); }
}
#endregion Implementation of IDictionaryEnumerator
#region Implementation of IEnumerator
public void Reset() {
_innerEnumerator.Reset();
}
public bool MoveNext() {
return _innerEnumerator.MoveNext();
}
object IEnumerator.Current {
get { return Current; }
}
public ConfigurationDictionaryEntry Current {
get { return new ConfigurationDictionaryEntry (Key, Value); }
}
#endregion Implementation of IEnumerator
}
public sealed class ConfigurationDictionaryEntry {
private readonly Configuration _name;
private readonly ConfigurationBase _config;
internal ConfigurationDictionaryEntry(Configuration name, ConfigurationBase config) {
_name = name;
_config = config;
}
public Configuration Name {
get { return _name; }
}
public ConfigurationBase Config {
get { return _config; }
}
}
}
nant-0.92-rc1/src/NAnt.VSNet/NAnt.VSNet.build 0000644 0001750 0001750 00000002757 11757302274 020350 0 ustar jtaylor jtaylor
nant-0.92-rc1/src/NAnt.VSNet/ReferencesResolver.cs 0000644 0001750 0001750 00000010207 11757302274 021610 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
// Scott Ford (sford@RJKTECH.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.Remoting.Lifetime;
using System.Xml;
using Microsoft.Win32;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
public class ReferencesResolver : MarshalByRefObject {
#region Override implementation of MarshalByRefObject
///
/// Obtains a lifetime service object to control the lifetime policy for
/// this instance.
///
///
/// An object of type used to control the lifetime
/// policy for this instance. This is the current lifetime service object
/// for this instance if one exists; otherwise, a new lifetime service
/// object initialized with a lease that will never time out.
///
public override Object InitializeLifetimeService() {
ILease lease = (ILease) base.InitializeLifetimeService();
if (lease.CurrentState == LeaseState.Initial) {
lease.InitialLeaseTime = TimeSpan.Zero;
}
return lease;
}
#endregion Override implementation of MarshalByRefObject
#region Public Instance Methods
public void AppendReferencedModulesLocatedInGivenDirectory(string moduleDirectory, string moduleName, ref Hashtable allReferences, ref Hashtable unresolvedReferences) {
Assembly module = null;
try {
module = Assembly.LoadFrom(moduleName);
} catch (FileLoadException) {
// for now ignore assemblies that cannot be loaded. A better
// solution might be to disable signature verification and try
// again, that way we can load assemblies that are delay-signed
return;
}
AssemblyName[] referencedAssemblies = module.GetReferencedAssemblies();
foreach (AssemblyName referencedAssemblyName in referencedAssemblies) {
string fullPathToReferencedAssembly = FileUtils.CombinePaths(moduleDirectory, referencedAssemblyName.Name + ".dll");
// we only add referenced assemblies which are located in given directory
if (File.Exists(fullPathToReferencedAssembly) && !allReferences.ContainsKey(fullPathToReferencedAssembly)) {
allReferences.Add(fullPathToReferencedAssembly, null);
unresolvedReferences.Add(fullPathToReferencedAssembly, null);
}
}
}
///
/// Gets the file name of the assembly with the given assembly name.
///
/// The assembly name of the assembly of which the file name should be returned.
///
/// The file name of the assembly with the given assembly name.
///
public string GetAssemblyFileName(string assemblyName) {
Assembly assembly = Assembly.Load(assemblyName);
return (new Uri(assembly.CodeBase)).LocalPath;
}
#endregion Public Instance Methods
}
} nant-0.92-rc1/src/NAnt.VSNet/SolutionBase.cs 0000644 0001750 0001750 00000110576 11757302274 020426 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.VSNet.Tasks;
using NAnt.VSNet.Types;
namespace NAnt.VSNet {
public abstract class SolutionBase {
#region Protected Instance Constructors
protected SolutionBase(SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver) : this(tfc, solutionTask) {
if (solutionTask.SolutionFile != null) {
_file = solutionTask.SolutionFile;
} else {
LoadProjectGuids(new ArrayList(solutionTask.Projects.FileNames), false);
LoadProjectGuids(new ArrayList(solutionTask.ReferenceProjects.FileNames), true);
LoadProjects(gacCache, refResolver, CollectionsUtil.CreateCaseInsensitiveHashtable());
}
}
#endregion Protected Instance Constructors
#region Private Instance Constructors
private SolutionBase(TempFileCollection tfc, SolutionTask solutionTask) {
_htOutputFiles = CollectionsUtil.CreateCaseInsensitiveHashtable();
_projectEntries = new ProjectEntryCollection();
_htReferenceProjects = CollectionsUtil.CreateCaseInsensitiveHashtable();
_tfc = tfc;
_solutionTask = solutionTask;
_outputDir = solutionTask.OutputDir;
_webMaps = solutionTask.WebMaps;
}
#endregion Private Instance Constructors
#region Public Instance Properties
public FileInfo File {
get { return _file; }
}
public TempFileCollection TemporaryFiles {
get { return _tfc; }
}
#endregion Public Instance Properties
#region Protected Instance Properties {
protected WebMapCollection WebMaps {
get { return _webMaps; }
}
public ProjectEntryCollection ProjectEntries {
get { return _projectEntries; }
}
#endregion Protected Instance Properties {
#region Public Instance Methods
public void RecursiveLoadTemplateProject(string fileName) {
XmlDocument doc = _solutionTask.ProjectFactory.LoadProjectXml(fileName);
foreach (XmlNode node in doc.SelectNodes("//Reference")) {
XmlNode projectGuidNode = node.SelectSingleNode("GUIDPROJECTID");
XmlNode fileNode = node.SelectSingleNode("FILE");
if (fileNode == null) {
Log(Level.Warning, "Reference with missing node. Skipping.");
continue;
}
// check if we're dealing with project or assembly reference
if (projectGuidNode != null) {
string subProjectFilename = node.SelectSingleNode("FILE").InnerText;
string fullPath;
// translate URLs to physical paths if using a webmap
string map = _webMaps.FindBestMatch(subProjectFilename);
if (map != null) {
Log(Level.Debug, "Found webmap match '{0}' for '{1}.",
map, subProjectFilename);
subProjectFilename = map;
}
try {
Uri uri = new Uri(subProjectFilename);
if (uri.Scheme == Uri.UriSchemeFile) {
fullPath = FileUtils.GetFullPath(FileUtils.CombinePaths(
Path.GetDirectoryName(fileName), uri.LocalPath));
} else {
fullPath = subProjectFilename;
if (!_solutionTask.EnableWebDav) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Cannot build web project '{0}'. Please use"
+ " to map the given URL to a project-relative"
+ " path, or specify enablewebdav=\"true\" on the"
+ " task element to use WebDAV.", fullPath));
}
}
} catch (UriFormatException) {
fullPath = FileUtils.GetFullPath(FileUtils.CombinePaths(
Path.GetDirectoryName(fileName), subProjectFilename));
}
// check if project file actually exists
if (!System.IO.File.Exists(fullPath)) {
throw CreateProjectDoesNotExistException(fullPath);
}
if (ManagedProjectBase.IsEnterpriseTemplateProject(fullPath)) {
RecursiveLoadTemplateProject(fullPath);
} else {
ProjectEntries.Add(new ProjectEntry(projectGuidNode.InnerText, fullPath));
}
} else {
Log(Level.Verbose, "Skipping file reference '{0}'.",
fileNode.InnerText);
}
}
}
///
/// Gets the project file of the project with the given unique identifier.
///
/// The unique identifier of the project for which the project file should be retrieves.
///
/// The project file of the project with the given unique identifier.
///
/// No project with unique identifier could be located.
public string GetProjectFileFromGuid(string projectGuid) {
// locate project entry using the project guid
ProjectEntry projectEntry = ProjectEntries[projectGuid];
// TODO : as an emergency patch throw a build error when a GUID fails
// to return a project file. This should be sanity checked when the
// HashTable is populated and not at usage time to avoid internal
// errors during build.
if (projectEntry == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Project with GUID '{0}' must be included for the build to"
+ " work.", projectGuid), Location.UnknownLocation);
}
return projectEntry.Path;
}
public ProjectBase GetProjectFromGuid(string projectGuid) {
ProjectEntry projectEntry = ProjectEntries[projectGuid];
if (projectEntry == null || projectEntry.Project == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Project with GUID '{0}' is not loaded.", projectGuid),
Location.UnknownLocation);
}
return projectEntry.Project;
}
public bool Compile(Configuration solutionConfiguration) {
Hashtable htProjectsDone = CollectionsUtil.CreateCaseInsensitiveHashtable();
Hashtable htFailedProjects = CollectionsUtil.CreateCaseInsensitiveHashtable();
ArrayList failedProjects = new ArrayList();
bool success = true;
GetDependenciesFromProjects(solutionConfiguration);
while (true) {
bool compiledThisRound = false;
foreach (ProjectEntry projectEntry in ProjectEntries) {
ProjectBase project = projectEntry.Project;
if (project == null) {
// mark project done
htProjectsDone[projectEntry.Guid] = null;
// skip projects that are not loaded/supported
continue;
}
if (htProjectsDone.Contains(project.Guid)) {
continue;
}
bool failed = htFailedProjects.Contains(project.Guid);
if (!failed) {
// attempt to convert assembly references to project
// references
//
// this might affect the build order as it can add
// project dependencies
if (FixProjectReferences(project, solutionConfiguration, htProjectsDone, htFailedProjects)) {
// mark project failed if it references a project that
// failed to build
//
// this can only happen when assembly reference was
// was fixed to a project reference (that already failed
// to build before the fix-up)
failed = true;
// avoid running through the fix-up next time
htFailedProjects[project.Guid] = null;
}
}
if (!HasDirtyProjectDependency(project, htProjectsDone)) {
try {
if (!_htReferenceProjects.Contains(project.Guid) && (failed || !project.Compile(solutionConfiguration))) {
if (!failed) {
Log(Level.Error, "Project '{0}' failed!", project.Name);
Log(Level.Error, "Continuing build with non-dependent projects.");
failedProjects.Add(project.Name);
}
success = false;
htFailedProjects[project.Guid] = null;
// mark the projects referencing this one as failed
foreach (ProjectEntry entry in ProjectEntries) {
ProjectBase dependentProject = entry.Project;
if (dependentProject == null) {
// skip projects that are not loaded/supported
}
// if the project depends on the failed
// project, then also mark it failed
if (dependentProject.ProjectDependencies.Contains(project)) {
htFailedProjects[dependentProject.Guid] = null;
}
}
}
} catch (BuildException) {
// Re-throw build exceptions
throw;
} catch (Exception e) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Unexpected error while compiling project '{0}'", project.Name),
Location.UnknownLocation, e);
}
compiledThisRound = true;
// mark project done
htProjectsDone[project.Guid] = null;
}
}
if (ProjectEntries.Count == htProjectsDone.Count) {
break;
}
if (!compiledThisRound) {
throw new BuildException("Circular dependency detected.", Location.UnknownLocation);
}
}
if (failedProjects.Count > 0) {
Log(Level.Error, string.Empty);
Log(Level.Error, "Solution failed to build! Failed projects were:" );
foreach (string projectName in failedProjects)
Log(Level.Error, " - " + projectName );
}
return success;
}
#endregion Public Instance Methods
#region Protected Instance Methods
///
/// Logs a message with the given priority.
///
/// The message priority at which the specified message is to be logged.
/// The message to be logged.
///
/// The actual logging is delegated to the underlying task.
///
protected void Log(Level messageLevel, string message) {
if (_solutionTask != null) {
_solutionTask.Log(messageLevel, message);
}
}
///
/// Logs a message with the given priority.
///
/// The message priority at which the specified message is to be logged.
/// The message to log, containing zero or more format items.
/// An array containing zero or more objects to format.
///
/// The actual logging is delegated to the underlying task.
///
protected void Log(Level messageLevel, string message, params object[] args) {
if (_solutionTask != null) {
_solutionTask.Log(messageLevel, message, args);
}
}
protected void LoadProjectGuids(ArrayList projects, bool isReferenceProject) {
foreach (string projectFileName in projects) {
string projectGuid = _solutionTask.ProjectFactory.LoadGuid(projectFileName);
// locate project entry using the project guid
ProjectEntry projectEntry = ProjectEntries[projectGuid];
if (projectEntry != null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Error loading project {0}. "
+ " Project GUID {1} already exists! Conflicting project is {2}.",
projectFileName, projectGuid, projectEntry.Path));
}
ProjectEntries.Add(new ProjectEntry(projectGuid, projectFileName));
if (isReferenceProject)
_htReferenceProjects[projectGuid] = null;
}
}
///
/// Loads the projects from the file system and stores them in an
/// instance variable.
///
/// instance to use to determine whether an assembly is located in the Global Assembly Cache.
/// instance to use to determine location and references of assemblies.
/// TODO
/// A project GUID in the solution file does not match the actual GUID of the project in the project file.
protected void LoadProjects(GacCache gacCache, ReferencesResolver refResolver, Hashtable explicitProjectDependencies) {
Log(Level.Verbose, "Loading projects...");
FileSet excludes = _solutionTask.ExcludeProjects;
foreach (ProjectEntry projectEntry in ProjectEntries) {
string projectPath = projectEntry.Path;
string projectGuid = projectEntry.Guid;
// determine whether project is on case-sensitive filesystem,
bool caseSensitive = PlatformHelper.IsVolumeCaseSensitive(projectPath);
// indicates whether the project should be skipped (excluded)
bool skipProject = false;
// check whether project should be excluded from build
foreach (string excludedProjectFile in excludes.FileNames) {
if (string.Compare(excludedProjectFile, projectPath, !caseSensitive, CultureInfo.InvariantCulture) == 0) {
Log(Level.Verbose, "Excluding project '{0}'.",
projectPath);
// do not load project
skipProject = true;
// we have a match, so quit looking
break;
}
}
if (skipProject) {
// remove dependencies for excluded projects
if (explicitProjectDependencies.ContainsKey(projectGuid)) {
explicitProjectDependencies.Remove(projectGuid);
}
// project was excluded, move on to next project
continue;
}
Log(Level.Verbose, "Loading project '{0}'.", projectPath);
ProjectBase p = _solutionTask.ProjectFactory.LoadProject(this, _solutionTask,
_tfc, gacCache, refResolver, _outputDir, projectPath);
if (p == null) {
Log(Level.Warning, "Project '{0}' is of unsupported type. Skipping.", projectPath);
// skip the project
continue;
}
if (p.Guid == null || p.Guid == string.Empty) {
p.Guid = FindGuidFromPath(projectPath);
}
// add project to entry
projectEntry.Project = p;
// set project build configuration
SetProjectBuildConfiguration(projectEntry);
}
// add explicit dependencies (as set in VS.NET) to individual projects
foreach (DictionaryEntry dependencyEntry in explicitProjectDependencies) {
string projectGuid = (string) dependencyEntry.Key;
Hashtable dependencies = (Hashtable) dependencyEntry.Value;
ProjectEntry projectEntry = ProjectEntries[projectGuid];
if (projectEntry == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Dependencies for project \'{0}\' could not be analyzed."
+ " Project is not included.", projectGuid),
Location.UnknownLocation);
}
ProjectBase project = projectEntry.Project;
// make sure project is loaded
if (project == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Dependencies for project \'{0}\' could not be analyzed."
+ " Project is not loaded.", projectGuid),
Location.UnknownLocation);
}
foreach (string dependentProjectGuid in dependencies.Keys) {
ProjectEntry dependentEntry = ProjectEntries[dependentProjectGuid];
if (dependentEntry == null || dependentEntry.Project == null) {
Log(Level.Warning, "Project \"{0}\": ignored dependency"
+ " on project \"{1}\", which is not included.",
project.Name, dependentProjectGuid);
continue;
}
project.ProjectDependencies.Add(dependentEntry.Project);
}
}
}
protected void GetDependenciesFromProjects(Configuration solutionConfiguration) {
Log(Level.Verbose, "Gathering additional dependencies...");
// first get all of the output files
foreach (ProjectEntry projectEntry in ProjectEntries) {
ProjectBase project = projectEntry.Project;
if (project == null) {
// skip projects that are not loaded/supported
continue;
}
foreach (ConfigurationBase projectConfig in project.ProjectConfigurations.Values) {
string projectOutputFile = projectConfig.OutputPath;
if (projectOutputFile != null) {
_htOutputFiles[projectOutputFile] = project.Guid;
}
}
}
// if one of output files resides in reference search path - circle began
// we must build project with that outputFile before projects referencing it
// (similar to project dependency) VS.NET 7.0/7.1 do not address this problem
// build list of output which reside in such folders
Hashtable outputsInAssemblyFolders = CollectionsUtil.CreateCaseInsensitiveHashtable();
foreach (DictionaryEntry de in _htOutputFiles) {
string outputfile = (string) de.Key;
string folder = Path.GetDirectoryName(outputfile);
if (_solutionTask.AssemblyFolderList.Contains(folder)) {
outputsInAssemblyFolders[Path.GetFileName(outputfile)] =
(string) de.Value;
}
}
// build the dependency list
foreach (ProjectEntry projectEntry in ProjectEntries) {
ProjectBase project = projectEntry.Project;
if (project == null) {
// skip projects that are not loaded/supported
continue;
}
// check if project actually supports the build configuration
ConfigurationBase projectConfig = project.BuildConfigurations[solutionConfiguration];
if (projectConfig == null) {
continue;
}
// ensure output directory exists. VS creates output directories
// before it starts compiling projects
if (!projectConfig.OutputDir.Exists) {
projectConfig.OutputDir.Create();
projectConfig.OutputDir.Refresh();
}
foreach (ReferenceBase reference in project.References) {
ProjectReferenceBase projectReference = reference as ProjectReferenceBase;
if (projectReference != null) {
project.ProjectDependencies.Add(projectReference.Project);
} else {
string outputFile = reference.GetPrimaryOutputFile(
solutionConfiguration);
// if we reference an assembly in an AssemblyFolder
// that is an output directory of another project,
// then add dependency on that project
if (outputFile == null) {
continue;
}
string dependencyGuid = (string) outputsInAssemblyFolders[Path.GetFileName(outputFile)];
if (dependencyGuid == null) {
continue;
}
ProjectEntry dependencyEntry = ProjectEntries[dependencyGuid];
if (dependencyEntry != null && dependencyEntry.Project != null) {
project.ProjectDependencies.Add(dependencyEntry.Project);
}
}
}
}
}
///
/// Translates a project path, in the form of a relative file path or
/// a URL, to an absolute file path.
///
/// The directory of the solution.
/// The project path to translate to an absolute file path.
///
/// The project path translated to an absolute file path.
///
protected string TranslateProjectPath(string solutionDir, string projectPath) {
if (solutionDir == null) {
throw new ArgumentNullException("solutionDir");
}
if (projectPath == null) {
throw new ArgumentNullException("projectPath");
}
string translatedPath = null;
// translate URLs to physical paths if using a webmap
string map = WebMaps.FindBestMatch(projectPath);
if (map != null) {
Log(Level.Debug, "Found webmap match '{0}' for '{1}.",
map, projectPath);
translatedPath = map;
} else {
translatedPath = projectPath;
}
try {
#if NET_2_0
Uri uri = null;
Uri.TryCreate(translatedPath, UriKind.Absolute, out uri);
#else
Uri uri = new Uri(translatedPath);
#endif
if(uri==null) {
translatedPath = FileUtils.GetFullPath(FileUtils.CombinePaths(
solutionDir, translatedPath));
} else if (uri.Scheme == Uri.UriSchemeFile) {
translatedPath = FileUtils.GetFullPath(FileUtils.CombinePaths(
solutionDir, uri.LocalPath));
} else {
if (!_solutionTask.EnableWebDav) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Cannot build web project '{0}'. Please use"
+ " to map the given URL to a project-relative"
+ " path, or specify enablewebdav=\"true\" on the"
+ " task element to use WebDAV.", translatedPath));
}
}
} catch (UriFormatException) {
translatedPath = FileUtils.GetFullPath(FileUtils.CombinePaths(
solutionDir, translatedPath));
}
return translatedPath;
}
///
/// Converts assembly references to projects to project references, adding
/// a build dependency.c
///
/// The to analyze.
/// The solution configuration that is built.
/// containing list of projects that have been built.
/// containing list of projects that failed to build.
protected bool FixProjectReferences(ProjectBase project, Configuration solutionConfiguration, Hashtable builtProjects, Hashtable failedProjects) {
// check if the project still has dependencies that have not been
// built
if (HasDirtyProjectDependency(project, builtProjects)) {
return false;
}
ConfigurationBase projectConfig = project.BuildConfigurations[solutionConfiguration];
// check if the project actually supports the build configuration
if (projectConfig == null) {
return false;
}
Log(Level.Verbose, "Fixing up references...");
ArrayList projectReferences = (ArrayList)
project.References.Clone();
bool referencesFailedProject = false;
foreach (ReferenceBase reference in projectReferences) {
AssemblyReferenceBase assemblyReference = reference as
AssemblyReferenceBase;
if (assemblyReference == null) {
// project references and wrappers don't
// need to be fixed
continue;
}
ProjectBase projectRef = null;
string outputFile = assemblyReference.GetPrimaryOutputFile(
solutionConfiguration);
if (outputFile == null) {
continue;
}
if (_htOutputFiles.Contains(outputFile)) {
// if the reference is an output file of
// another build configuration of a project
// and this output file wasn't built before
// then use the output file for the current
// build configuration
//
// eg. a project file might be referencing the
// the debug assembly of a given project as an
// assembly reference, but the projects are now
// being built in release configuration, so
// instead of failing the build we use the
// release assembly of that project
// Note that this was designed to intentionally
// deviate from VS.NET's building strategy.
// See "Reference Configuration Matching" at http://nant.sourceforge.net/wiki/index.php/SolutionTask
// for why we must always convert file references to project references
// If we want a different behaviour, this
// should be controlled by a flag
projectRef = ProjectEntries[(string) _htOutputFiles[outputFile]].Project;
} else if (_outputDir != null) {
// if an output directory is set, then the
// assembly reference might not have been
// resolved during Reference initialization,
// as the output file of the project might
// not have existed at that time
//
// this will perform matching on file name
// only, so its really tricky (VS.NET does
// not support this)
string projectOutput = FileUtils.CombinePaths(
_outputDir.FullName, Path.GetFileName(
outputFile));
if (_htOutputFiles.Contains(projectOutput)) {
projectRef = (ProjectBase) ProjectEntries[
(string) _htOutputFiles[projectOutput]].Project;
}
}
// try matching assembly reference and project on assembly name
// if the assembly file does not exist
if (projectRef == null && !System.IO.File.Exists(outputFile)) {
foreach (ProjectEntry projectEntry in ProjectEntries) {
// we can only do this for managed projects, as we only have
// an assembly name for these
ManagedProjectBase managedProject = projectEntry.Project as ManagedProjectBase;
if (managedProject == null) {
continue;
}
// check if the assembly names match
if (assemblyReference.Name == managedProject.ProjectSettings.AssemblyName) {
projectRef = managedProject;
break;
}
}
}
if (projectRef != null) {
if (!referencesFailedProject && failedProjects.ContainsKey(projectRef.Guid)) {
referencesFailedProject = true;
}
ProjectReferenceBase projectReference = assemblyReference.
CreateProjectReference(projectRef);
Log(Level.Verbose, "Converted assembly reference to project reference: {0} -> {1}",
assemblyReference.Name, projectReference.Name);
// remove assembly reference from project
project.References.Remove(assemblyReference);
// add project reference instead
project.References.Add(projectReference);
// unless referenced project has already been build, add
// referenced project as project dependency
if (!builtProjects.Contains(projectReference.Project.Guid)) {
project.ProjectDependencies.Add(projectReference.Project);
}
}
}
return referencesFailedProject;
}
protected BuildException CreateProjectDoesNotExistException(string projectPath) {
return new BuildException(string.Format(CultureInfo.InvariantCulture,
"Project '{0}' does not exist.", projectPath));
}
protected virtual void SetProjectBuildConfiguration(ProjectEntry projectEntry) {
if (projectEntry.BuildConfigurations == null) {
// project was not loaded from solution file, and as a result
// there's no project configuration section available, so we'll
// consider all project configurations as valid build
// configurations
ProjectBase project = projectEntry.Project;
project.BuildConfigurations.Clear();
foreach (ConfigurationDictionaryEntry ce in project.ProjectConfigurations) {
project.BuildConfigurations[ce.Name] = ce.Config;
}
} else {
// project was loaded from solution file, so only add build
// configurations that were listed in project configuration
// section
ProjectBase project = projectEntry.Project;
foreach (ConfigurationMapEntry ce in projectEntry.BuildConfigurations) {
Configuration solutionConfig = ce.Key;
Configuration projectConfig = ce.Value;
ConfigurationBase conf = project.ProjectConfigurations [projectConfig];
if (conf != null) {
project.BuildConfigurations[solutionConfig] = conf;
}
}
}
}
#endregion Protected Instance Methods
#region Private Instance Methods
///
/// Determines whether any of the project dependencies of the specified
/// project still needs to be built.
///
/// The to analyze.
/// containing list of projects that have been built.
///
/// if one of the project dependencies has not
/// yet been built; otherwise, .
///
private bool HasDirtyProjectDependency(ProjectBase project, Hashtable builtProjects) {
foreach (ProjectBase projectDependency in project.ProjectDependencies) {
if (!builtProjects.ContainsKey(projectDependency.Guid)) {
return true;
}
}
return false;
}
private string FindGuidFromPath(string projectPath) {
foreach (ProjectEntry projectEntry in ProjectEntries) {
if (string.Compare(projectEntry.Path, projectPath, true, CultureInfo.InvariantCulture) == 0) {
return projectEntry.Guid;
}
}
return string.Empty;
}
#endregion Private Instance Methods
#region Private Instance Fields
private readonly FileInfo _file;
private readonly ProjectEntryCollection _projectEntries;
private readonly Hashtable _htOutputFiles;
private readonly Hashtable _htReferenceProjects;
private readonly SolutionTask _solutionTask;
private readonly WebMapCollection _webMaps;
private readonly DirectoryInfo _outputDir;
private readonly TempFileCollection _tfc;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/FileReferenceBase.cs 0000644 0001750 0001750 00000014607 11757302274 021306 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Matthew Mastracci (matt@aclaro.com)
// Scott Ford (sford@RJKTECH.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
namespace NAnt.VSNet {
public abstract class FileReferenceBase : ReferenceBase {
#region Protected Instance Constructors
protected FileReferenceBase(XmlElement xmlDefinition, ReferencesResolver referencesResolver, ProjectBase parent, GacCache gacCache) : base(referencesResolver, parent) {
if (xmlDefinition == null) {
throw new ArgumentNullException("xmlDefinition");
}
if (gacCache == null) {
throw new ArgumentNullException("gacCache");
}
_xmlDefinition = xmlDefinition;
_gacCache = gacCache;
}
#endregion Protected Instance Constructors
#region Protected Instance Properties
protected XmlElement XmlDefinition {
get { return _xmlDefinition; }
}
protected GacCache GacCache {
get { return _gacCache; }
}
#endregion Protected Instance Properties
#region Override implementation of ReferenceBase
///
/// Gets a value indicating whether the reference is managed for the
/// specified configuration.
///
/// The build configuration of the reference.
///
/// .
///
public override bool IsManaged(Configuration config) {
return true;
}
#endregion Override implementation of ReferenceBase
#region Protected Instance Methods
///
/// Gets the complete set of output files for the specified assembly
/// and adds them to collection.
///
/// The path of the assembly to get the output files for.
/// The set of output files to be updated.
///
/// The key of the case-insensitive is the
/// full path of the output file and the value is the path relative to
/// the output directory.
///
protected void GetAssemblyOutputFiles(string assemblyFile, Hashtable outputFiles) {
if (!File.Exists(assemblyFile)) {
// no need to output warning if set of output files cannot be
// generated
return;
}
if (!outputFiles.ContainsKey(assemblyFile)) {
string[] referencedModules = GetAllReferencedModules(assemblyFile);
// get a list of the references in the output directory
foreach (string referenceFile in referencedModules) {
// skip module if module is not the assembly referenced by
// the project and is installed in GAC
if (string.Compare(referenceFile, assemblyFile, true, CultureInfo.InvariantCulture) != 0) {
// skip referenced module if the assembly referenced by
// the project is a system reference or the module itself
// is installed in the GAC
if (IsSystem || GacCache.IsAssemblyInGac(referenceFile)) {
continue;
}
}
// get list of files related to referenceFile, this will include
// referenceFile itself
GetRelatedFiles(referenceFile, outputFiles);
}
}
}
#endregion Protected Instance Methods
#region Private Instance Methods
private string[] GetAllReferencedModules(string module) {
string fullPathToModule = FileUtils.GetFullPath(module);
string moduleDirectory = Path.GetDirectoryName(fullPathToModule);
Hashtable allReferences = new Hashtable();
Hashtable unresolvedReferences = new Hashtable();
try {
allReferences.Add(fullPathToModule, null);
unresolvedReferences.Add(fullPathToModule, null);
while (unresolvedReferences.Count > 0) {
IDictionaryEnumerator unresolvedEnumerator = unresolvedReferences.GetEnumerator();
unresolvedEnumerator.MoveNext();
string referenceToResolve = (string) unresolvedEnumerator.Key;
unresolvedReferences.Remove(referenceToResolve);
ReferencesResolver.AppendReferencedModulesLocatedInGivenDirectory(
moduleDirectory, referenceToResolve, ref allReferences,
ref unresolvedReferences);
}
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Error resolving module references of '{0}'.", fullPathToModule),
Location.UnknownLocation, ex);
}
string[] result = new string[allReferences.Keys.Count];
allReferences.Keys.CopyTo(result, 0);
return result;
}
#endregion Private Instance Methods
#region Private Instance Fields
private readonly XmlElement _xmlDefinition;
private readonly GacCache _gacCache;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VSNet/JSharpProjectProvider.cs 0000644 0001750 0001750 00000003712 11757302274 022241 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Martin Aliger (martin_aliger@myrealbox.com)
using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Xml;
using NAnt.Core;
using NAnt.Core.Util;
using NAnt.VSNet.Extensibility;
using NAnt.VSNet.Tasks;
namespace NAnt.VSNet {
internal class JSharpProjectProvider : IProjectBuildProvider {
#region Implementation of IProjectBuildProvider
public int IsSupported(string projectExt, XmlElement xmlDefinition) {
if (projectExt == ".vjsproj")
return 5;
if (JSharpProject.IsSupported(xmlDefinition))
return 10;
return 0;
}
public ProjectBase GetInstance(SolutionBase solution, string projectPath, XmlElement xmlDefinition, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver, DirectoryInfo outputDir) {
return new JSharpProject(solution, projectPath, xmlDefinition, solutionTask, tfc, gacCache, refResolver, outputDir);
}
public string LoadGuid(XmlElement xmlDefinition) {
return JSharpProject.LoadGuid(xmlDefinition);
}
#endregion Implementation of IProjectBuildProvider
}
}
nant-0.92-rc1/src/NAnt.VSNet/Configuration.cs 0000644 0001750 0001750 00000007264 11757302274 020625 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2008 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net.be)
using System;
using System.Globalization;
namespace NAnt.VSNet {
public class Configuration : IComparable {
public Configuration() {
}
public Configuration(string name, string platform) {
if (name == null)
throw new ArgumentNullException ("name");
_name = name;
_platform = platform;
}
public string Name {
get { return _name; }
set {
if (value == null)
throw new ArgumentNullException ("value");
_name = value;
}
}
public string Platform {
get {
if (_platform == null)
return string.Empty;
return _platform;
}
set { _platform = value; }
}
#region Implementation of IComparable
public int CompareTo(object obj) {
if (this.Equals(obj))
return 0;
return 1;
}
#endregion Implementation of IComparable
#region Override implementation of Object
public override bool Equals(object obj) {
if (obj == null)
return false;
Configuration config = obj as Configuration;
if (config == null)
return false;
return (string.Compare (Name, config.Name, true, CultureInfo.InvariantCulture) == 0)
&& (string.Compare (Platform, config.Platform, true, CultureInfo.InvariantCulture) == 0);
}
public override int GetHashCode() {
return Name.ToLower (CultureInfo.InvariantCulture).GetHashCode ()
^ Platform.ToLower (CultureInfo.InvariantCulture).GetHashCode ();
}
public override string ToString() {
if (Platform.Length == 0) {
return Name;
}
return Name + "|" + Platform;
}
#endregion Override implementation of Object
public static bool operator == (Configuration c1, Configuration c2) {
if ((object) c1 == null) {
return ((object) c2 == null);
}
return c1.Equals (c2);
}
public static bool operator != (Configuration c1, Configuration c2) {
return !(c1 == c2);
}
public static Configuration Parse (string config) {
if (config == null) {
throw new ArgumentNullException ("config");
}
int index = config.IndexOf("|");
if (index > 0 && index < config.Length) {
return new Configuration (config.Substring(0, index),
config.Substring (index + 1));
} else {
return new Configuration (config, null);
}
}
private string _name;
private string _platform;
}
}
nant-0.92-rc1/src/NAnt.Console/ 0000755 0001750 0001750 00000000000 11757310030 016046 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.Console/NAnt.Console.csproj 0000644 0001750 0001750 00000015163 11757302272 021550 0 ustar jtaylor jtaylor
DebugAnyCPU2.0{859696F8-F405-4018-A155-D34561498A3E}NAnt.ConsoleNAntExeOnSuccessfulBuildfalse8.0.50727v2.02.0publish\trueDiskfalseForeground7Daysfalsefalsetrue01.0.0.%2afalsefalsetruetruefullfalse4..\..\build\Debug\AllRules.rulesetTRACE;DEBUG..\..\build\Debug\NAnt.xmltruepdbonlytrue..\..\build\Release\4AllRules.rulesetTRACE..\..\build\Release\NAnt.xml..\..\lib\common\neutral\log4net.dll
CommonAssemblyInfo.cs
False.NET Framework 3.5 SP1 Client ProfilefalseFalse.NET Framework 3.5 SP1trueFalseWindows Installer 3.1true{8F80C098-94A4-44DB-A25D-C9E455FC3120}NAnt.Compression{8F5F8375-4097-4952-B860-784EB9961ABE}NAnt.Core{B50A1067-785B-4686-8FFC-5AF424BEF163}NAnt.DotNet{318C04B2-D982-4243-9C6A-CA7E035E927D}NAnt.MSBuild{ED13C268-36DE-49CE-B347-C2BE03F814B9}NAnt.MSNet{00F5C075-9874-4BCE-909A-99C1F600E047}NAnt.NUnit{0F3EA7A9-C5F6-4254-820C-B5E0409B5B9D}NAnt.NUnit1{47503BEE-27D9-4D1C-B8E1-6C9CCC19AEAA}NAnt.NUnit2{6B2EC648-8D69-4096-B4F9-6EDC0B2F98EF}NAnt.SourceControl{F77EA08E-9473-436A-BBA3-880139A341B1}NAnt.Tests{A154DB17-7263-44E3-838E-1E4C4946B7D8}NAnt.VisualCpp{DD434690-B4DF-4BF9-91FE-F139A41E2474}NAnt.VSNet{C66545A2-6FEC-4A38-937A-5B25E61EE8A1}NAnt.Win32{841FAEBA-4527-410A-B765-E2EDA47ABDCE}NDoc.Documenter.NAnt nant-0.92-rc1/src/NAnt.Console/AssemblyInfo.cs 0000644 0001750 0001750 00000003157 11757302272 021007 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Scott Hernandez (ScottHernandez@hotmail.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System.Reflection;
// Configure log4net using the application configuration file
// (AppDomain.CurrentDomain.SetupInformation.ConfigurationFile).
// The application configuration file will be directly accessed
// by log4net (not using the System.Configuration namespace).
// The log4net configuration will be reloaded whenever the
// configuration file is changed.
[assembly: log4net.Config.XmlConfigurator(Watch=true)]
// This will not compile with Visual Studio. If you want to build a signed
// executable use the NAnt build file. To build under Visual Studio just
// exclude this file from the build.
[assembly: AssemblyDelaySign(false)]
//[assembly: AssemblyKeyFile(@"..\NAnt.key")]
[assembly: AssemblyKeyName("")]
nant-0.92-rc1/src/NAnt.Console/NAnt.Console.build 0000644 0001750 0001750 00000006154 11757302272 021347 0 ustar jtaylor jtaylor
nant-0.92-rc1/src/NAnt.Console/App.config 0000644 0001750 0001750 00000527175 11757302272 020007 0 ustar jtaylor jtaylor
truetruesnlcfalsefalsetruetruesnlctruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruesnlctruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruesnlctruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruesnlctrueThe .NET Framework 1.1 SDK is not installed.truetruetruecfresgensnlcThe .NET Framework 2.0 SDK is not installed.truetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruesnlctruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruesnlctruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruesnlctruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruesnlctruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruetruesnlctruetrue${csc.tool}truetruetrue${csc.supportsdocgeneration}truetruetruetruemjstrue${mbas.tool}true${resgen.tool}truesntruefalsetruetruegmcstruetruetrue${csc.supportsdocgeneration}truetruetruetruemjsstrictvbnctrue${resgen.tool}true${resgen.supportsexternalfilereferences}sntruefalsetruetruegmcstruelinqtruetruetruetruetruetruetruemjsstrictvbnctruetruetruesntruefalsetruetruedmcstruelinqtruetruetruetruetruetruetruemjsstrictvbnctruetruetruesntruefalsetruesmcstruetruetruetruetruetruetruetruetruetruesnfalsetruetruesnfalsetruetrueUnable to locate 'mono' module using pkg-config. Download the Mono development packages from http://www.mono-project.com/downloads/.true${path::combine(prefix, 'lib/mono/1.0/mcs.exe')}truetruetrue${csc.supportsdocgeneration}truetruetruetruemjstrue${path::combine(prefix, 'lib/mono/1.0/mbas.exe')}true${resgen.tool}truesntruefalsetrueUnable to locate 'mono' module using pkg-config. Download the Mono development packages from http://www.mono-project.com/downloads/.truegmcstruetruetrue${csc.supportsdocgeneration}truetruetruetruemjsstrictvbnctrue${resgen.tool}true${resgen.supportsexternalfilereferences}sntruefalsetrueUnable to locate 'mono' module using pkg-config. Download the Mono development packages from http://www.mono-project.com/downloads/.truegmcstruelinqtruetruetruetruetruetruetruemjsstrictvbnctruetruetruesntruefalsetrueUnable to locate 'mono' module using pkg-config. Download the Mono development packages from http://www.mono-project.com/downloads/.truedmcstruelinqtruetruetruetruetruetruetruemjsstrictvbnctruetruetruesntruefalsetrueUnable to locate 'mono' module using pkg-config. Download the Mono development packages from http://www.mono-project.com/downloads/.smcstruetruetruetruetruetruetruetruetruetruesnfalse
nant-0.92-rc1/src/NAnt.Console/ConsoleStub.cs 0000644 0001750 0001750 00000052770 11757302272 020661 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2002-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Scott Hernandez (ScottHernandez@hotmail.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.IO;
using System.Collections;
using System.Configuration;
using System.Reflection;
using System.Globalization;
using System.Text;
using System.Xml;
using System.Security;
using System.Security.Permissions;
using System.Security.Policy;
namespace NAnt.Console {
///
/// Stub used to created and launch real ConsoleDriver
/// class in Core assembly.
///
public class ConsoleStub {
#region Static Constructor
static ConsoleStub() {
// check a class in mscorlib to determine if we're running on Mono
if (Type.GetType("System.MonoType", false) != null) {
FrameworkFamily = "mono";
} else {
FrameworkFamily = "net";
}
// check for non-Unix platforms - see FAQ for more details
// http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
int platform = (int) Environment.OSVersion.Platform;
if (platform != 4 && platform != 128) {
Platform = "win32";
} else {
Platform = "unix";
}
}
#endregion Static Constructor
#region Public Static Methods
///
/// Entry point for executable
///
/// Command Line arguments
/// The result of the real execution
[STAThread]
public static int Main(string[] args) {
AppDomain cd = AppDomain.CurrentDomain;
AppDomain executionAD = cd;
string nantShadowCopyFilesSetting = ConfigurationManager.AppSettings.Get("nant.shadowfiles");
string nantCleanupShadowCopyFilesSetting = ConfigurationManager.AppSettings.Get("nant.shadowfiles.cleanup");
Framework runtimeFramework = Framework.GetRuntimeFramework();
if (runtimeFramework == null) {
// signal error
return 1;
}
string privateBinPath = ConstructPrivateBinPath(runtimeFramework,
AppDomain.CurrentDomain.BaseDirectory);
if (nantShadowCopyFilesSetting != null && bool.Parse(nantShadowCopyFilesSetting) == true) {
logger.Debug(string.Format(
CultureInfo.InvariantCulture,
"Shadowing files({0}) -- cleanup={1}",
nantShadowCopyFilesSetting,
nantCleanupShadowCopyFilesSetting));
System.AppDomainSetup myDomainSetup = new System.AppDomainSetup();
myDomainSetup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
logger.Debug(string.Format(
CultureInfo.InvariantCulture,
"NAntDomain.PrivateBinPath={0}",
myDomainSetup.PrivateBinPath));
myDomainSetup.PrivateBinPath = privateBinPath;
myDomainSetup.ApplicationName = "NAnt";
// copy the config file location
myDomainSetup.ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
logger.Debug(string.Format(
CultureInfo.InvariantCulture,
"NAntDomain.ConfigurationFile={0}",
myDomainSetup.ConfigurationFile));
// yes, cache the files
myDomainSetup.ShadowCopyFiles = "true";
// shadowcopy everything in base directory of appdomain and
// privatebinpath
myDomainSetup.ShadowCopyDirectories = myDomainSetup.ApplicationBase
+ Path.PathSeparator + myDomainSetup.PrivateBinPath;
logger.Debug(string.Format(
CultureInfo.InvariantCulture,
"NAntDomain.ShadowCopyDirectories={0}",
myDomainSetup.ShadowCopyDirectories));
// try to cache in .\cache folder, if that fails, let the system
// figure it out.
string cachePath = Path.Combine(myDomainSetup.ApplicationBase, "cache");
DirectoryInfo cachePathInfo = null;
try {
cachePathInfo = Directory.CreateDirectory(cachePath);
} catch (Exception e) {
System.Console.WriteLine("Failed to create: {0}. Using default CachePath." + e.ToString(), cachePath);
} finally {
if(cachePathInfo != null) {
myDomainSetup.CachePath = cachePathInfo.FullName;
}
logger.Debug(string.Format(
CultureInfo.InvariantCulture,
"NAntDomain.CachePath={0}",
myDomainSetup.CachePath));
}
// create the domain.
PermissionSet myDomainPermSet = new PermissionSet(PermissionState.Unrestricted);
executionAD = AppDomain.CreateDomain(myDomainSetup.ApplicationName, AppDomain.CurrentDomain.Evidence,
myDomainSetup, myDomainPermSet);
logger.Debug(string.Format(
CultureInfo.InvariantCulture,
"NAntDomain.SetupInfo:\n{0}",
executionAD.SetupInformation));
}
// use helper object to hold (and serialize) args for callback.
logger.Debug(string.Format(
CultureInfo.InvariantCulture,
"Creating HelperArgs({0})",
args.ToString()));
HelperArguments helper = new HelperArguments(args,
privateBinPath);
executionAD.DoCallBack(new CrossAppDomainDelegate(helper.CallConsoleRunner));
// unload if remote/new appdomain
if (!cd.Equals(executionAD)) {
string cachePath = executionAD.SetupInformation.CachePath;
logger.Debug(string.Format(
CultureInfo.InvariantCulture,
"Unloading '{0}' AppDomain",
executionAD.FriendlyName));
AppDomain.Unload(executionAD);
if (nantCleanupShadowCopyFilesSetting != null && bool.Parse(nantCleanupShadowCopyFilesSetting) == true) {
logger.Debug(string.Format(
CultureInfo.InvariantCulture,
"Unloading '{0}' AppDomain",
executionAD.FriendlyName));
try {
logger.Debug(string.Format(
CultureInfo.InvariantCulture,
"Cleaning up CacheFiles in '{0}'",
cachePath));
Directory.Delete(cachePath, true);
} catch (FileNotFoundException ex) {
logger.Error("Files not found.", ex);
} catch (Exception ex) {
System.Console.WriteLine("Unable to delete cache path '{1}'.\n\n{0}.", ex.ToString(), cachePath);
}
}
}
if (helper == null || helper.ExitCode == -1) {
logger.Debug(string.Format(
CultureInfo.InvariantCulture,
"Return Code null or -1"));
throw new ApplicationException("No return code set!");
} else {
logger.Debug(string.Format(
CultureInfo.InvariantCulture,
"Return Code = {0}",
helper.ExitCode));
return helper.ExitCode;
}
}
#endregion Public Static Methods
#region Private Static Methods
///
/// Constructs the privatebinpath.
///
///
///
/// For the common version dir, we do not use the framework version
/// as defined in the NAnt configuration file but the CLR version
/// since the assemblies in that directory are not specific to a
/// certain family and the framwork version might differ between
/// families (eg. mono 1.0 == .NET 1.1).
///
///
/// The runtime framework.
/// The base directory of the domain.
///
/// The privatebinpath.
///
private static string ConstructPrivateBinPath (Framework runtimeFramework, string baseDir) {
StringBuilder sb = new StringBuilder ();
foreach (string probePath in runtimeFramework.ProbePaths) {
string fullDir = Path.Combine (baseDir, probePath);
AppendPrivateBinDir(baseDir, fullDir, sb);
}
// add privatebinpath of current domain to privatebinpath
if (AppDomain.CurrentDomain.SetupInformation.PrivateBinPath != null) {
if (sb.Length > 0) {
sb.Append(Path.PathSeparator);
}
sb.Append(AppDomain.CurrentDomain.SetupInformation.PrivateBinPath);
}
return sb.ToString();
}
private static void AppendPrivateBinDir(string baseDir, string dir, StringBuilder sb) {
if (!Directory.Exists (dir)) {
return;
}
if (sb.Length != 0) {
sb.Append(Path.PathSeparator);
}
sb.Append(GetRelativePath(baseDir, dir));
string[] subDirs = Directory.GetDirectories(dir);
for (int i = 0; i < subDirs.Length; i++) {
AppendPrivateBinDir(baseDir, subDirs[i], sb);
}
}
///
/// Given an absolute directory and an absolute file name, returns a
/// relative file name.
///
/// An absolute directory.
/// An absolute file name.
///
/// A relative file name for the given absolute file name.
///
private static string GetRelativePath(string basePath, string absolutePath) {
string fullBasePath = Path.GetFullPath(basePath);
string fullAbsolutePath = Path.GetFullPath(absolutePath);
bool caseInsensitive = false;
// check if we're not on unix
if ((int) Environment.OSVersion.Platform != 128) {
// for simplicity, we'll consider all filesystems on windows
// to be case-insensitive
caseInsensitive = true;
// on windows, paths with different roots are located on different
// drives, so only absolute names will do
if (string.Compare(Path.GetPathRoot(fullBasePath), Path.GetPathRoot(fullAbsolutePath), caseInsensitive) != 0) {
return fullAbsolutePath;
}
}
int baseLen = fullBasePath.Length;
int absoluteLen = fullAbsolutePath.Length;
// they are on the same "volume", find out how much of the base path
// is in the absolute path
int i = 0;
while (i < absoluteLen && i < baseLen && string.Compare(fullBasePath[i].ToString(), fullAbsolutePath[i].ToString(), caseInsensitive) == 0) {
i++;
}
if (i == baseLen && (fullAbsolutePath[i] == Path.DirectorySeparatorChar || fullAbsolutePath[i-1] == Path.DirectorySeparatorChar)) {
// the whole current directory name is in the file name,
// so we just trim off the current directory name to get the
// current file name.
if (fullAbsolutePath[i] == Path.DirectorySeparatorChar) {
// a directory name might have a trailing slash but a relative
// file name should not have a leading one...
i++;
}
return fullAbsolutePath.Substring(i);
}
// The file is not in a child directory of the current directory, so we
// need to step back the appropriate number of parent directories by
// using ".."s. First find out how many levels deeper we are than the
// common directory
string commonPath = fullBasePath.Substring(0, i);
int levels = 0;
string parentPath = fullBasePath;
// remove trailing directory separator character
if (parentPath[parentPath.Length - 1] == Path.DirectorySeparatorChar) {
parentPath = parentPath.Substring(0, parentPath.Length - 1);
}
while (string.Compare(parentPath,commonPath, caseInsensitive) != 0) {
levels++;
DirectoryInfo parentDir = Directory.GetParent(parentPath);
if (parentDir != null) {
parentPath = parentDir.FullName;
} else {
parentPath = null;
}
}
string relativePath = "";
for (i = 0; i < levels; i++) {
relativePath += ".." + Path.DirectorySeparatorChar;
}
relativePath += fullAbsolutePath.Substring(commonPath.Length);
return relativePath;
}
#endregion Private Static Methods
#region Private Static Fields
private static readonly string FrameworkFamily;
private static readonly string Platform;
private static readonly log4net.ILog logger = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
#endregion Private Static Fields
///
/// Helper class for invoking the application entry point in NAnt.Core
/// and passing the command-line arguments.
///
[Serializable()]
private class HelperArguments : MarshalByRefObject {
#region Public Instance Constructors
///
/// Initializes a new instance of the
/// class with the specified command-line arguments.
///
/// The commandline arguments passed to NAnt.exe.
/// Directories relative to the base directory of the AppDomain to probe for missing assembly references.
public HelperArguments(string[] args, string probePaths) {
_args = args;
_probePaths = probePaths;
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets the status that the build process returned when it exited.
///
///
/// The code that the build process specified when it terminated.
///
public int ExitCode {
get { return _exitCode; }
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Invokes the application entry point in NAnt.Core.
///
public void CallConsoleRunner() {
// explicitly add the lib directory to privatebinpath although
// its added to privatebinpath in the config file, as entries
// in the config file are not reflected in SetupInformation
if (Directory.Exists(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "lib"))) {
AppDomain.CurrentDomain.AppendPrivatePath("lib");
}
// add framework specific entries to privatebinpath
if (_probePaths != null) {
foreach (string probePath in _probePaths.Split(Path.PathSeparator)) {
logger.Debug(string.Format(CultureInfo.InvariantCulture,
"Adding '{0}' to private bin path.", probePath));
AppDomain.CurrentDomain.AppendPrivatePath(probePath);
}
}
MethodInfo mainMethodInfo = null;
//load the core by name!
Assembly nantCore = AppDomain.CurrentDomain.Load("NAnt.Core");
logger.Info(string.Format(
CultureInfo.InvariantCulture,
"NAnt.Core Loaded: {0}",
nantCore.FullName));
//get the ConsoleDriver by name
Type consoleDriverType = nantCore.GetType("NAnt.Core.ConsoleDriver", true, true);
//find the Main Method, this method is less than optimal, but other methods failed.
foreach (MethodInfo methodInfo in consoleDriverType.GetMethods(BindingFlags.Static | BindingFlags.Public)) {
if (methodInfo.Name.Equals("Main")) {
mainMethodInfo = methodInfo;
break;
}
}
// invoke the Main method and pass the command-line arguments as parameter.
_exitCode = (int) mainMethodInfo.Invoke(null, new object[] {_args});
logger.Debug(string.Format(
CultureInfo.InvariantCulture,
"'{0}' returned {1}",
mainMethodInfo.ToString(), ExitCode));
}
#endregion Public Instance Methods
#region Private Instance Fields
private string[] _args;
private string _probePaths;
private int _exitCode = -1;
#endregion Private Instance Fields
#region Private Static Fields
private static readonly log4net.ILog logger = log4net.LogManager.GetLogger(
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
#endregion Private Static Fields
}
private class Framework {
private readonly string _version;
private readonly string[] _probePaths;
private Framework (string version, string [] probePaths) {
_version = version;
_probePaths = probePaths;
}
public string Version {
get { return _version; }
}
public string [] ProbePaths {
get { return _probePaths; }
}
public static Framework GetRuntimeFramework () {
XmlNode nantNode = (XmlNode) ConfigurationManager.GetSection("nant");
if (nantNode == null) {
System.Console.WriteLine("The \"nant\" section in the NAnt"
+ " configuration file ({0}) is not available.",
AppDomain.CurrentDomain.SetupInformation.ConfigurationFile);
return null;
}
XmlElement frameworkNode = (XmlElement) nantNode.SelectSingleNode("frameworks/platform[@name='" + Platform + "']/framework[@family='" + FrameworkFamily + "' and @clrversion='" + Environment.Version.ToString(3) + "']");
if (frameworkNode == null) {
System.Console.WriteLine("The NAnt configuration file ({0})"
+ " does not have a node for the current"
+ " runtime framework.",
AppDomain.CurrentDomain.SetupInformation.ConfigurationFile);
System.Console.WriteLine(string.Empty);
System.Console.WriteLine("Please add a node"
+ " with family '{0}' and clrversion '{1}' under the"
+ " '{2}' platform node.", FrameworkFamily,
Environment.Version.ToString(3), Platform);
return null;
}
string frameworkVersion = frameworkNode.GetAttribute("version");
XmlNodeList includeNodes = frameworkNode.SelectNodes("runtime/probing-paths/directory");
ArrayList includes = new ArrayList (includeNodes.Count);
foreach (XmlNode node in includeNodes) {
XmlElement includeNode = (XmlElement) node;
string name = includeNode.GetAttribute("name");
includes.Add (name);
}
string[] probePaths = new string[includes.Count];
includes.CopyTo (probePaths, 0);
return new Framework(frameworkVersion, probePaths);
}
}
}
}
nant-0.92-rc1/src/NAnt.VisualCpp/ 0000755 0001750 0001750 00000000000 11757310030 016352 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.VisualCpp/AssemblyInfo.cs 0000644 0001750 0001750 00000002332 11757302274 021307 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gerry Shaw (gerry_shaw@yahoo.com)
// Scott Hernandez (ScottHernandez@hotmail.com)
// Gert Driesen (drieseng@users.sourceforge.net)
using System.Reflection;
// This will not compile with Visual Studio. If you want to build a signed
// executable use the NAnt build file. To build under Visual Studio just
// exclude this file from the build.
[assembly: AssemblyDelaySign(false)]
//[assembly: AssemblyKeyFile(@"..\NAnt.key")]
[assembly: AssemblyKeyName("")] nant-0.92-rc1/src/NAnt.VisualCpp/Types/ 0000755 0001750 0001750 00000000000 11757310030 017456 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.VisualCpp/Types/Symbol.cs 0000644 0001750 0001750 00000006033 11757302274 021267 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2005 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using NAnt.Core;
using NAnt.Core.Attributes;
namespace NAnt.VisualCpp.Types {
///
/// Represents a symbol.
///
public class Symbol : Element {
#region Private Instance Fields
private string _symbolName;
private bool _ifDefined = true;
private bool _unlessDefined;
#endregion Private Instance Fields
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public Symbol() {
}
///
/// Initializes a new instance of the class with
/// the specified name.
///
/// is .
public Symbol(string name) {
if (name == null) {
throw new ArgumentNullException("name");
}
_symbolName = name;
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// The name of the symbol.
///
[TaskAttribute("name", Required=true)]
[StringValidator(AllowEmpty=false)]
public string SymbolName {
get { return _symbolName; }
set { _symbolName = value; }
}
///
/// If then the element will be processed;
/// otherwise, skipped. The default is .
///
[TaskAttribute("if")]
[BooleanValidator()]
public bool IfDefined {
get { return _ifDefined; }
set { _ifDefined = value; }
}
///
/// If then the element will be skipped;
/// otherwise, processed. The default is .
///
[TaskAttribute("unless")]
[BooleanValidator()]
public bool UnlessDefined {
get { return _unlessDefined; }
set { _unlessDefined = value; }
}
#endregion Public Instance Properties
}
}
nant-0.92-rc1/src/NAnt.VisualCpp/Types/CharacterSet.cs 0000644 0001750 0001750 00000001021 11757302274 022362 0 ustar jtaylor jtaylor using System;
namespace NAnt.VisualCpp.Types {
///
/// Defines the character sets that can be used by the C++ compiler.
///
public enum CharacterSet {
///
/// Have the compiler determine the character set.
///
NotSet = 0,
///
/// Unicode character set.
///
Unicode = 1,
///
/// Multi-byte character set.
///
MultiByte = 2
}
}
nant-0.92-rc1/src/NAnt.VisualCpp/Types/SymbolCollection.cs 0000644 0001750 0001750 00000021235 11757302274 023304 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2005 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
namespace NAnt.VisualCpp.Types {
///
/// Contains a collection of elements.
///
[Serializable()]
public class SymbolCollection : CollectionBase {
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public SymbolCollection() {
}
///
/// Initializes a new instance of the class
/// with the specified instance.
///
public SymbolCollection(SymbolCollection value) {
AddRange(value);
}
///
/// Initializes a new instance of the class
/// with the specified array of instances.
///
public SymbolCollection(Symbol[] value) {
AddRange(value);
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets or sets the element at the specified index.
///
/// The zero-based index of the element to get or set.
[System.Runtime.CompilerServices.IndexerName("Item")]
public Symbol this[int index] {
get {return ((Symbol)(base.List[index]));}
set {base.List[index] = value;}
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Adds a to the end of the collection.
///
/// The to be added to the end of the collection.
/// The position into which the new element was inserted.
public int Add(Symbol item) {
return base.List.Add(item);
}
///
/// Adds the elements of a array to the end of the collection.
///
/// The array of elements to be added to the end of the collection.
public void AddRange(Symbol[] items) {
for (int i = 0; (i < items.Length); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Adds the elements of a to the end of the collection.
///
/// The to be added to the end of the collection.
public void AddRange(SymbolCollection items) {
for (int i = 0; (i < items.Count); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Determines whether a is in the collection.
///
/// The to locate in the collection.
///
/// if is found in the
/// collection; otherwise, .
///
public bool Contains(Symbol item) {
return base.List.Contains(item);
}
///
/// Copies the entire collection to a compatible one-dimensional array, starting at the specified index of the target array.
///
/// The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.
/// The zero-based index in at which copying begins.
public void CopyTo(Symbol[] array, int index) {
base.List.CopyTo(array, index);
}
///
/// Retrieves the index of a specified object in the collection.
///
/// The object for which the index is returned.
///
/// The index of the specified . If the is not currently a member of the collection, it returns -1.
///
public int IndexOf(Symbol item) {
return base.List.IndexOf(item);
}
///
/// Inserts a into the collection at the specified index.
///
/// The zero-based index at which should be inserted.
/// The to insert.
public void Insert(int index, Symbol item) {
base.List.Insert(index, item);
}
///
/// Returns an enumerator that can iterate through the collection.
///
///
/// A for the entire collection.
///
public new SymbolEnumerator GetEnumerator() {
return new SymbolEnumerator(this);
}
///
/// Removes a member from the collection.
///
/// The to remove from the collection.
public void Remove(Symbol item) {
base.List.Remove(item);
}
#endregion Public Instance Methods
}
///
/// Enumerates the elements of a .
///
public class SymbolEnumerator : IEnumerator {
#region Internal Instance Constructors
///
/// Initializes a new instance of the class
/// with the specified .
///
/// The collection that should be enumerated.
internal SymbolEnumerator(SymbolCollection arguments) {
IEnumerable temp = (IEnumerable) (arguments);
_baseEnumerator = temp.GetEnumerator();
}
#endregion Internal Instance Constructors
#region Implementation of IEnumerator
///
/// Gets the current element in the collection.
///
///
/// The current element in the collection.
///
public Symbol Current {
get { return (Symbol) _baseEnumerator.Current; }
}
object IEnumerator.Current {
get { return _baseEnumerator.Current; }
}
///
/// Advances the enumerator to the next element of the collection.
///
///
/// if the enumerator was successfully advanced
/// to the next element; if the enumerator has
/// passed the end of the collection.
///
public bool MoveNext() {
return _baseEnumerator.MoveNext();
}
bool IEnumerator.MoveNext() {
return _baseEnumerator.MoveNext();
}
///
/// Sets the enumerator to its initial position, which is before the
/// first element in the collection.
///
public void Reset() {
_baseEnumerator.Reset();
}
void IEnumerator.Reset() {
_baseEnumerator.Reset();
}
#endregion Implementation of IEnumerator
#region Private Instance Fields
private IEnumerator _baseEnumerator;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VisualCpp/Types/Library.cs 0000644 0001750 0001750 00000006047 11757302274 021433 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2005 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using NAnt.Core;
using NAnt.Core.Attributes;
namespace NAnt.VisualCpp.Types {
///
/// Represents a library.
///
public class Library : Element {
#region Private Instance Fields
private string _libraryName;
private bool _ifDefined = true;
private bool _unlessDefined;
#endregion Private Instance Fields
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public Library() {
}
///
/// Initializes a new instance of the class with
/// the specified name.
///
/// is .
public Library(string name) {
if (name == null) {
throw new ArgumentNullException("name");
}
_libraryName = name;
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// The name of the library.
///
[TaskAttribute("name", Required=true)]
[StringValidator(AllowEmpty=false)]
public string LibraryName {
get { return _libraryName; }
set { _libraryName = value; }
}
///
/// If then the element will be processed;
/// otherwise, skipped. The default is .
///
[TaskAttribute("if")]
[BooleanValidator()]
public bool IfDefined {
get { return _ifDefined; }
set { _ifDefined = value; }
}
///
/// If then the element will be skipped;
/// otherwise, processed. The default is .
///
[TaskAttribute("unless")]
[BooleanValidator()]
public bool UnlessDefined {
get { return _unlessDefined; }
set { _unlessDefined = value; }
}
#endregion Public Instance Properties
}
}
nant-0.92-rc1/src/NAnt.VisualCpp/Types/LibraryCollection.cs 0000644 0001750 0001750 00000021316 11757302274 023443 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2005 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Gert Driesen (drieseng@users.sourceforge.net)
using System;
using System.Collections;
namespace NAnt.VisualCpp.Types {
///
/// Contains a collection of elements.
///
[Serializable()]
public class LibraryCollection : CollectionBase {
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public LibraryCollection() {
}
///
/// Initializes a new instance of the class
/// with the specified instance.
///
public LibraryCollection(LibraryCollection value) {
AddRange(value);
}
///
/// Initializes a new instance of the class
/// with the specified array of instances.
///
public LibraryCollection(Library[] value) {
AddRange(value);
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Gets or sets the element at the specified index.
///
/// The zero-based index of the element to get or set.
[System.Runtime.CompilerServices.IndexerName("Item")]
public Library this[int index] {
get {return ((Library)(base.List[index]));}
set {base.List[index] = value;}
}
#endregion Public Instance Properties
#region Public Instance Methods
///
/// Adds a to the end of the collection.
///
/// The to be added to the end of the collection.
/// The position into which the new element was inserted.
public int Add(Library item) {
return base.List.Add(item);
}
///
/// Adds the elements of a array to the end of the collection.
///
/// The array of elements to be added to the end of the collection.
public void AddRange(Library[] items) {
for (int i = 0; (i < items.Length); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Adds the elements of a to the end of the collection.
///
/// The to be added to the end of the collection.
public void AddRange(LibraryCollection items) {
for (int i = 0; (i < items.Count); i = (i + 1)) {
Add(items[i]);
}
}
///
/// Determines whether a is in the collection.
///
/// The to locate in the collection.
///
/// if is found in the
/// collection; otherwise, .
///
public bool Contains(Library item) {
return base.List.Contains(item);
}
///
/// Copies the entire collection to a compatible one-dimensional array, starting at the specified index of the target array.
///
/// The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.
/// The zero-based index in at which copying begins.
public void CopyTo(Library[] array, int index) {
base.List.CopyTo(array, index);
}
///
/// Retrieves the index of a specified object in the collection.
///
/// The object for which the index is returned.
///
/// The index of the specified . If the is not currently a member of the collection, it returns -1.
///
public int IndexOf(Library item) {
return base.List.IndexOf(item);
}
///
/// Inserts a into the collection at the specified index.
///
/// The zero-based index at which should be inserted.
/// The to insert.
public void Insert(int index, Library item) {
base.List.Insert(index, item);
}
///
/// Returns an enumerator that can iterate through the collection.
///
///
/// A for the entire collection.
///
public new LibraryEnumerator GetEnumerator() {
return new LibraryEnumerator(this);
}
///
/// Removes a member from the collection.
///
/// The to remove from the collection.
public void Remove(Library item) {
base.List.Remove(item);
}
#endregion Public Instance Methods
}
///
/// Enumerates the elements of a .
///
public class LibraryEnumerator : IEnumerator {
#region Internal Instance Constructors
///
/// Initializes a new instance of the class
/// with the specified .
///
/// The collection that should be enumerated.
internal LibraryEnumerator(LibraryCollection arguments) {
IEnumerable temp = (IEnumerable) (arguments);
_baseEnumerator = temp.GetEnumerator();
}
#endregion Internal Instance Constructors
#region Implementation of IEnumerator
///
/// Gets the current element in the collection.
///
///
/// The current element in the collection.
///
public Library Current {
get { return (Library) _baseEnumerator.Current; }
}
object IEnumerator.Current {
get { return _baseEnumerator.Current; }
}
///
/// Advances the enumerator to the next element of the collection.
///
///
/// if the enumerator was successfully advanced
/// to the next element; if the enumerator has
/// passed the end of the collection.
///
public bool MoveNext() {
return _baseEnumerator.MoveNext();
}
bool IEnumerator.MoveNext() {
return _baseEnumerator.MoveNext();
}
///
/// Sets the enumerator to its initial position, which is before the
/// first element in the collection.
///
public void Reset() {
_baseEnumerator.Reset();
}
void IEnumerator.Reset() {
_baseEnumerator.Reset();
}
#endregion Implementation of IEnumerator
#region Private Instance Fields
private IEnumerator _baseEnumerator;
#endregion Private Instance Fields
}
}
nant-0.92-rc1/src/NAnt.VisualCpp/Util/ 0000755 0001750 0001750 00000000000 11757310030 017267 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.VisualCpp/Util/ArgumentUtils.cs 0000644 0001750 0001750 00000015101 11757302274 022432 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2004 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Hani Atassi (haniatassi@users.sourceforge.net)
using System;
using System.ComponentModel;
namespace NAnt.VisualCpp.Util {
///
/// Defines how to deal with backslashes in values of command line
/// arguments.
///
public enum BackslashProcessingMethod {
///
/// Does not perform any processing on backslashes.
///
None = 0,
///
/// Duplicates the trailing backslash.
///
Duplicate = 1,
///
/// Fixes the trailing backslash by replaces trailing double backslashes
/// with only one backslash and removing single trailing backslashes.
///
Fix = 2,
///
/// Removes all the trailing backslashes.
///
Clean = 3
}
///
/// Groups a set of useful manipulation methods for
/// command-line arguments.
///
public class ArgumentUtils {
///
/// Performs backslash processing on the specified value using a given
/// method.
///
/// The to process.
/// The to use.
///
/// with backslashes processed using the given
/// .
///
public static string ProcessTrailingBackslash(string value, BackslashProcessingMethod processingMethod) {
string processedValue = null;
switch (processingMethod) {
case BackslashProcessingMethod.None:
processedValue = value;
break;
case BackslashProcessingMethod.Duplicate:
processedValue = DuplicateTrailingBackslash(value);
break;
case BackslashProcessingMethod.Fix:
processedValue = FixTrailingBackslash(value);
break;
case BackslashProcessingMethod.Clean:
processedValue = CleanTrailingBackslash(value);
break;
default:
throw new InvalidEnumArgumentException("processingMethod",
(int) processingMethod, typeof(BackslashProcessingMethod));
}
return processedValue;
}
///
/// Duplicates the trailing backslash.
///
/// The input string to check and duplicate the trailing backslash if necessary.
/// The result string after being processed.
///
/// Also duplicates trailing backslash in quoted value.
///
public static string DuplicateTrailingBackslash(string value) {
if (value == null) {
throw new ArgumentNullException("value");
}
if (value.Length == 0) {
return value;
}
bool isQuoted = value.Length > 2 && value.StartsWith("\"") && value.EndsWith("\"");
int lastIndex = (isQuoted ? value.Length - 2 : value.Length - 1);
if (value[lastIndex] == '\\') {
return value.Insert(lastIndex, @"\");
}
return value;
}
///
/// Fixes the trailing backslash. This function replaces the trailing double backslashes with
/// only one backslash. It also, removes the single trailing backslash.
///
/// The input string.
/// The result string after being processed.
public static string FixTrailingBackslash(string value) {
if (value == null) {
throw new ArgumentNullException("value");
}
if (value.Length == 0) {
return value;
}
if (value.EndsWith(@"\\")) {
return value.Remove(value.Length - 2, 2) + @"\";
} else if (value.EndsWith(@"\")) {
return value.Remove(value.Length - 1, 1);
} else {
return value;
}
}
///
/// Removes all the trailing backslashes from the input.
///
/// The input string.
/// The result string without trailing backslashes.
public static string CleanTrailingBackslash(string value) {
if (value == null) {
throw new ArgumentNullException("value");
}
return value.TrimEnd('\\');
}
///
/// Quotes an argument value and processes backslashes using a given
/// .
///
/// The argument value to quote.
/// The to use.
///
/// The quoted argument value.
///
public static string QuoteArgumentValue(string value, BackslashProcessingMethod processingMethod) {
// duplicate trailing backslashes (even if value is quoted)
string quotedValue = ArgumentUtils.ProcessTrailingBackslash(value, processingMethod);
// determine if value is already quoted
bool isQuoted = value.StartsWith("\"") && value.EndsWith("\"");
if (!isQuoted) {
quotedValue = "\"" + quotedValue + "\"";
}
return quotedValue;
}
}
}
nant-0.92-rc1/src/NAnt.VisualCpp/Tasks/ 0000755 0001750 0001750 00000000000 11757310030 017437 5 ustar jtaylor jtaylor nant-0.92-rc1/src/NAnt.VisualCpp/Tasks/RcTask.cs 0000644 0001750 0001750 00000025061 11757302274 021174 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
// Shawn Van Ness (nantluver@arithex.com)
// Gerry Shaw (gerry_shaw@yahoo.com)
// Ian MacLean ( ian@maclean.ms )
// Eric V. Smith (ericsmith@windsor.com)
// Hani Atassi (haniatassi@users.sourceforge.net)
// TODO: review interface for future compatibility/customizations issues
using System;
using System.Globalization;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.VisualCpp.Util;
namespace NAnt.VisualCpp.Tasks {
///
/// Compiles resources using rc.exe, Microsoft's Win32 resource
/// compiler.
///
///
///
/// Compile text.rc to text.res using the default options.
///
///
///
/// ]]>
///
///
///
///
/// Compile text.rc, passing an additional option.
///
///
///
/// ]]>
///
///
[TaskName("rc")]
public class RcTask : ExternalProgramBase {
#region Private Instance Fields
private FileInfo _outputFile;
private string _options;
private int _langId = 0;
private FileInfo _rcFile;
private FileSet _includeDirs = new FileSet();
private OptionCollection _defines = new OptionCollection();
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Options to pass to the compiler.
///
[TaskAttribute("options")]
public string Options {
get { return _options; }
set { _options = value; }
}
///
/// Output file.
///
[TaskAttribute("output")]
public FileInfo OutputFile {
get {
if (_outputFile == null) {
_outputFile = new FileInfo(Path.ChangeExtension(RcFile.FullName, "RES"));
}
return _outputFile;
}
set { _outputFile = value; }
}
///
/// The resource file to compile.
///
[TaskAttribute("rcfile", Required=true)]
public FileInfo RcFile {
get { return _rcFile; }
set { _rcFile = value; }
}
///
/// Default language ID.
///
[TaskAttribute("langid", Required=false)]
public int LangId {
get { return _langId; }
set { _langId = value; }
}
///
/// The list of directories in which to search for include files.
///
[BuildElement("includedirs")]
public FileSet IncludeDirs {
get { return _includeDirs; }
set { _includeDirs = value; }
}
///
/// Macro definitions to pass to rc.exe.
/// Each entry will generate a /d
///
[BuildElementCollection("defines", "define")]
public OptionCollection Defines {
get { return _defines; }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Filename of program to execute
///
public override string ProgramFileName {
get { return Name; }
}
///
/// Arguments of program to execute
///
public override string ProgramArguments {
get {
StringBuilder str = new StringBuilder();
if (Verbose) {
str.Append("/v ");
}
str.AppendFormat(CultureInfo.InvariantCulture,
"/fo\"{0}\" ", OutputFile.FullName);
if (Options != null) {
str.AppendFormat(CultureInfo.InvariantCulture,
"{0} ", Options);
}
if (LangId != 0) {
str.AppendFormat("/l 0x{0:X} ", LangId);
}
// append user provided include directories
foreach (string include in IncludeDirs.DirectoryNames) {
str.AppendFormat("/i {0} ", ArgumentUtils.QuoteArgumentValue(
include, BackslashProcessingMethod.Duplicate));
}
// append user definitions
foreach (Option define in Defines) {
if (!define.IfDefined || define.UnlessDefined) {
continue;
}
if (define.Value == null) {
str.AppendFormat("/d {0} ", ArgumentUtils.DuplicateTrailingBackslash(define.OptionName));
} else {
str.AppendFormat("/d {0}={1} ", define.OptionName, ArgumentUtils.DuplicateTrailingBackslash(define.Value));
}
}
str.AppendFormat(CultureInfo.InvariantCulture,
"\"{0}\" ", RcFile.FullName);
return str.ToString();
}
}
///
/// Compile the resource file
///
protected override void ExecuteTask() {
if (IncludeDirs.BaseDirectory == null) {
IncludeDirs.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (NeedsCompiling()) {
Log(Level.Info, "Compiling \"{0}\" to \"{1}\".", RcFile.FullName,
OutputFile.FullName);
base.ExecuteTask();
}
}
#endregion Override implementation of ExternalProgramBase
#region Protected Instance Methods
///
/// Determines if the resource need compiling.
///
protected virtual bool NeedsCompiling() {
if (!OutputFile.Exists) {
Log(Level.Verbose, "'{0}' does not exist, recompiling.",
OutputFile.FullName);
return true;
}
// if output file file is older the resource file, it is stale
string fileName = FileSet.FindMoreRecentLastWriteTime(
RcFile.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' is out of date, recompiling.",
fileName);
return true;
}
// if resource file does not exist, then let compiler handle error
if (!RcFile.Exists) {
return true;
}
// check whether external files have been updated
Regex regBitmap = new Regex("IDB_(?\\w+)\\s+BITMAP\\s+\\\"(?[^\\\"]+)\\\"", RegexOptions.Singleline | RegexOptions.IgnoreCase);
Regex regIcon = new Regex("IDI_(?\\w+)\\s+ICON\\s+\\\"(?[^\\\"]+)\\\"", RegexOptions.Singleline | RegexOptions.IgnoreCase);
Regex regBinary = new Regex("IDR_(?\\w+)\\s+(?\\w+)\\s+\\\"(?[^\\\"]+)\\\"", RegexOptions.Singleline | RegexOptions.IgnoreCase);
using (StreamReader sr = new StreamReader(RcFile.FullName)) {
while (sr.Peek() != -1) {
string line = sr.ReadLine();
Match resourceMatch = regBitmap.Match(line);
if (resourceMatch.Success) {
return CheckResourceTimeStamp(resourceMatch.Groups["file"].Value);
}
resourceMatch = regIcon.Match(line);
if (resourceMatch.Success) {
return CheckResourceTimeStamp(resourceMatch.Groups["file"].Value);
}
resourceMatch = regBinary.Match(line);
if (resourceMatch.Success) {
return CheckResourceTimeStamp(resourceMatch.Groups["file"].Value);
}
}
}
// output file is up-to-date
return false;
}
///
/// Check if a resource file has been updated.
///
///
///
private bool CheckResourceTimeStamp(string filePath ) {
string fileName;
string externalFile = Path.Combine(RcFile.DirectoryName,
filePath);
fileName = FileSet.FindMoreRecentLastWriteTime(
externalFile, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, recompiling.",
fileName);
return true;
}
return false;
}
#endregion Protected Instance Methods
}
}
#if unused
Microsoft (R) Windows (R) Resource Compiler, Version 5.1.2264.1 - Build 2264
Copyright (C) Microsoft Corp. 1985-1998. All rights reserved.
Usage: rc [options] .RC input file
Switches:
/r Emit .RES file (optional)
/v Verbose (print progress messages)
/d Define a symbol
/u Undefine a symbol
/fo Rename .RES file
/l Default language ID in hex
/i Add a path for INCLUDE searches
/x Ignore INCLUDE environment variable
/c Define a code page used by NLS conversion
/w Warn on Invalid codepage in .rc (default is an error)
/y Don't warn if there are duplicate control ID's
/n Append null's to all strings in the string tables.
Flags may be either upper or lower case
#endif
nant-0.92-rc1/src/NAnt.VisualCpp/Tasks/LibTask.cs 0000644 0001750 0001750 00000023656 11757302274 021346 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Shawn Van Ness (nantluver@arithex.com)
// Gerry Shaw (gerry_shaw@yahoo.com)
// Ian MacLean (ian@maclean.ms)
// Eric V. Smith (ericsmith@windsor.com)
//
// TODO: review interface for future compatibility/customizations issues
using System;
using System.IO;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.VisualCpp.Types;
using NAnt.VisualCpp.Util;
namespace NAnt.VisualCpp.Tasks {
///
/// Run lib.exe, Microsoft's Library Manager.
///
///
/// Create a library.
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("lib")]
public class LibTask : ExternalProgramBase {
#region Private Instance Fields
private string _responseFileName;
private FileInfo _outputFile;
private FileInfo _moduleDefinitionFile;
private FileSet _sources = new FileSet();
private SymbolCollection _symbols = new SymbolCollection();
private LibraryCollection _ignoreLibraries = new LibraryCollection();
private FileSet _libdirs = new FileSet();
private string _options;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Options to pass to the compiler.
///
[TaskAttribute("options")]
public string Options {
get { return _options; }
set { _options = value; }
}
///
/// The output file.
///
[TaskAttribute("output", Required=true)]
public FileInfo OutputFile {
get { return _outputFile; }
set { _outputFile = value; }
}
///
/// The module definition file.
///
[TaskAttribute("moduledefinition")]
public FileInfo ModuleDefinitionFile {
get { return _moduleDefinitionFile; }
set { _moduleDefinitionFile = value; }
}
///
/// The list of files to combine into the output file.
///
[BuildElement("sources")]
public FileSet Sources {
get { return _sources; }
set { _sources = value; }
}
///
/// Symbols to add to the symbol table.
///
[BuildElementCollection("symbols", "symbol")]
public SymbolCollection Symbols {
get { return _symbols; }
set { _symbols = value; }
}
///
/// Names of default libraries to ignore.
///
[BuildElementCollection("ignorelibraries", "library")]
public LibraryCollection IgnoreLibraries {
get { return _ignoreLibraries; }
set { _ignoreLibraries = value; }
}
///
/// The list of additional library directories to search.
///
[BuildElement("libdirs")]
public FileSet LibDirs {
get { return _libdirs; }
set { _libdirs = value; }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Gets the filename of the external program to start.
///
/// The filename of the external program.
public override string ProgramFileName {
get { return Name; }
}
///
/// Gets the command-line arguments for the external program.
///
///
/// The command-line arguments for the external program.
///
public override string ProgramArguments {
get { return "@" + "\"" + _responseFileName + "\""; }
}
#endregion Override implementation of ExternalProgramBase
#region Override implementation of Task
///
/// Creates the library.
///
protected override void ExecuteTask() {
// ensure base directory is set, even if fileset was not initialized
// from XML
if (Sources.BaseDirectory == null) {
Sources.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (LibDirs.BaseDirectory == null) {
LibDirs.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (!NeedsCompiling()) {
return;
}
Log(Level.Info, "Combining {0} files to '{1}'.",
Sources.FileNames.Count, OutputFile.FullName);
// Create temp response file to hold compiler options
_responseFileName = Path.GetTempFileName();
StreamWriter writer = new StreamWriter(_responseFileName);
try {
// specify the output file
writer.WriteLine("/OUT:\"{0}\"", OutputFile.FullName);
// write user provided options
if (Options != null) {
writer.WriteLine(Options);
}
// write each of the filenames
foreach (string filename in Sources.FileNames) {
writer.WriteLine(ArgumentUtils.QuoteArgumentValue(filename,
BackslashProcessingMethod.None));
}
// write symbols
foreach (Symbol symbol in Symbols) {
if (symbol.IfDefined && !symbol.UnlessDefined) {
writer.WriteLine("/INCLUDE:{0}", ArgumentUtils.QuoteArgumentValue(
symbol.SymbolName, BackslashProcessingMethod.Duplicate));
}
}
// names of default libraries to ignore
foreach (Library ignoreLibrary in IgnoreLibraries) {
if (ignoreLibrary.IfDefined && !ignoreLibrary.UnlessDefined) {
writer.WriteLine("/NODEFAULTLIB:{0}", ArgumentUtils.QuoteArgumentValue(
ignoreLibrary.LibraryName, BackslashProcessingMethod.Duplicate));
}
}
// write each of the libdirs
foreach (string libdir in LibDirs.DirectoryNames) {
writer.WriteLine("/LIBPATH:{0}", ArgumentUtils.QuoteArgumentValue(
libdir, BackslashProcessingMethod.None));
}
if (ModuleDefinitionFile != null) {
writer.WriteLine("/DEF:\"{0}\"", ModuleDefinitionFile.FullName);
}
// suppresses display of the sign-on banner
writer.WriteLine("/nologo");
writer.Close();
if (Verbose) {
// display response file contents
Log(Level.Info, "Contents of {0}.", _responseFileName);
StreamReader reader = File.OpenText(_responseFileName);
Log(Level.Info, reader.ReadToEnd());
reader.Close();
}
// call base class to do the actual work
base.ExecuteTask();
} finally {
// make sure we delete response file even if an exception is thrown
writer.Close(); // make sure stream is closed or file cannot be deleted
File.Delete(_responseFileName);
_responseFileName = null;
}
}
#endregion Override implementation of Task
#region Protected Instance Methods
///
/// Determines if the sources need to be linked.
///
protected virtual bool NeedsCompiling() {
// check if output file exists - if not, rebuild
if (!OutputFile.Exists) {
Log(Level.Verbose, "Output file '{0}' does not exist, rebuilding library.",
OutputFile.FullName);
return true;
}
// check if .OBJ files were updated
string fileName = FileSet.FindMoreRecentLastWriteTime(
Sources.FileNames, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, relinking.", fileName);
return true;
}
return false;
}
#endregion Protected Instance Methods
}
}
#if unused
Microsoft (R) Library Manager Version 7.00.9466
Copyright (C) Microsoft Corporation. All rights reserved.
usage: LIB [options] [files]
options:
/DEF[:filename]
/EXPORT:symbol
/EXTRACT:membername
/INCLUDE:symbol
/LIBPATH:dir
/LIST[:filename]
/MACHINE:{AM33|ARM|IA64|M32R|MIPS|MIPS16|MIPSFPU|MIPSFPU16|MIPSR41XX|
PPC|PPCFP|SH3|SH3DSP|SH4|SH5|THUMB|TRICORE|X86}
/NAME:filename
/NODEFAULTLIB[:library]
/NOLOGO
/OUT:filename
/REMOVE:membername
/SUBSYSTEM:{CONSOLE|EFI_APPLICATION|EFI_BOOT_SERVICE_DRIVER|
EFI_ROM|EFI_RUNTIME_DRIVER|NATIVE|POSIX|WINDOWS|
WINDOWSCE}[,#[.##]]
/VERBOSE
#endif
nant-0.92-rc1/src/NAnt.VisualCpp/Tasks/McTask.cs 0000644 0001750 0001750 00000020565 11757302274 021173 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Kevin Connors (connors@karmet.com)
// Ian MacLean (ian_maclean@another.com)
using System.Globalization;
using System.IO;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Util;
namespace NAnt.VisualCpp.Tasks {
///
/// Compiles messages using mc.exe, Microsoft's Win32 message compiler.
///
///
///
/// Compile text.mc using the default options.
///
///
///
/// ]]>
///
///
/// Compile text.mc, passing a path to store the header, the rc
/// file and some additonal options.
///
///
///
/// ]]>
///
///
[TaskName("mc")]
public class McTask : ExternalProgramBase {
#region Private Instance Fields
private DirectoryInfo _headerPath;
private DirectoryInfo _rcPath;
private string _options;
private FileInfo _mcFile;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Options to pass to the compiler.
///
[TaskAttribute("options")]
public string Options {
get { return _options; }
set { _options = value; }
}
///
/// Path to store header file. The default is the project base directory.
///
[TaskAttribute("headerpath")]
public DirectoryInfo HeaderPath {
get {
if (_headerPath == null) {
return new DirectoryInfo(Project.BaseDirectory);
}
return _headerPath;
}
set { _headerPath = value; }
}
///
/// Path to store RC file. The default is the project base directory.
///
[TaskAttribute("rcpath")]
public DirectoryInfo RCPath {
get {
if (_rcPath == null) {
return new DirectoryInfo(Project.BaseDirectory);
}
return _rcPath;
}
set { _rcPath = value; }
}
///
/// Input filename.
///
[TaskAttribute("mcfile", Required=true)]
public FileInfo McFile {
get { return _mcFile; }
set { _mcFile = value; }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Gets the filename of the external program to start.
///
///
/// The filename of the external program.
///
public override string ProgramFileName {
get { return Name; }
}
///
/// Gets the command-line arguments for the external program.
///
///
/// The command-line arguments for the external program.
///
public override string ProgramArguments {
get {
string str = "";
if (Verbose) {
str += "/v ";
}
if (HeaderPath != null) {
str += string.Format(CultureInfo.InvariantCulture,
"-h \"{0}\" ", HeaderPath.FullName);
}
if (RCPath != null) {
str += string.Format(CultureInfo.InvariantCulture,
"-r \"{0}\" ", RCPath.FullName);
}
if (Options != null) {
str += string.Format(CultureInfo.InvariantCulture,
"{0} ", Options);
}
str += string.Format(CultureInfo.InvariantCulture,
"\"{0}\" ", McFile.FullName);
return str.ToString();
}
}
#endregion Override implementation of ExternalProgramBase
#region Override implementation of Task
///
/// Compiles the sources.
///
protected override void ExecuteTask() {
string header = Path.Combine(HeaderPath.FullName, Path.GetFileNameWithoutExtension(McFile.FullName)) + ".h";
string rc = Path.Combine(RCPath.FullName, Path.GetFileNameWithoutExtension(McFile.FullName)) + ".rc";
if (!NeedsCompiling(header) && !NeedsCompiling(rc)) {
Log(Level.Info, "Target(s) up-to-date, not compiling '{0}'.",
McFile.FullName);
} else {
Log(Level.Info, "Target out of date, compiling '{0}'.",
McFile.FullName);
if (HeaderPath != null) {
Log(Level.Info, "Header file to '{0}'.", HeaderPath.FullName);
}
if (RCPath != null) {
Log(Level.Info, "RC file to '{0}'.", RCPath.FullName);
}
Log(Level.Info, "");
base.ExecuteTask();
}
}
#endregion Override implementation of Task
#region Private Instance Methods
///
/// Determine if source files need re-building.
///
private bool NeedsCompiling(string destinationFile) {
if (McFile.Exists) {
FileInfo dstInfo = new FileInfo(Project.GetFullPath(destinationFile));
if ((!dstInfo.Exists) || (McFile.LastWriteTime > dstInfo.LastWriteTime)) {
return true;
} else {
return false;
}
} else {
// if the source file doesn't exist, let the compiler throw the error
Log(Level.Info, "Source file '{0}' doesn't exist!", McFile.FullName);
return true;
}
}
#endregion Private Instance Methods
}
}
#if unused
Microsoft (R) Message Compiler Version 1.00.5239
Copyright (c) Microsoft Corp 1992-1995. All rights reserved.
usage:
MC [-?vcdwso] [-m maxmsglen] [-h dirspec] [-e extension] [-r dirspec] [-x dbgFileSpec] [-u] [-U] filename.mc
-? - displays this message
-v - gives verbose output.
-c - sets the Customer bit in all the message Ids.
-d - FACILTY and SEVERITY values in header file in decimal.
Sets message values in header to decimal initially.
-w - warns if message text contains non-OS/2 compatible inserts.
-s - insert symbolic name as first line of each message.
-o - generate OLE2 header file (use HRESULT definition instead of
status code definition)
-m maxmsglen - generate a warning if the size of any message exceeds
maxmsglen characters.
-h pathspec - gives the path of where to create the C include file
Default is .\
-e extension - Specify the extension for the header file.
From 1 - 3 chars.
-r pathspec - gives the path of where to create the RC include file
and the binary message resource files it includes.
Default is .\
-x pathspec - gives the path of where to create the .dbg C include
file that maps message Ids to their symbolic name.
-u - input file is Unicode.
-U - messages in .BIN file should be Unicode.
filename.mc - gives the names of a message text file
to compile.
Generated files have the Archive bit cleared.
#endif
nant-0.92-rc1/src/NAnt.VisualCpp/Tasks/ClTask.cs 0000644 0001750 0001750 00000107463 11757302274 021175 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2002 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Shawn Van Ness (nantluver@arithex.com)
// Gerry Shaw (gerry_shaw@yahoo.com)
// Ian MacLean (ian@maclean.ms)
// Eric V. Smith (ericsmith@windsor.com)
// Anthony LoveFrancisco (ants@fu.org)
// Hani Atassi (haniatassi@users.sourceforge.net)
//
// TODO: review interface for future compatibility/customizations issues
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.VisualCpp.Types;
using NAnt.VisualCpp.Util;
namespace NAnt.VisualCpp.Tasks {
///
/// Compiles C/C++ programs using cl.exe, Microsoft's C/C++ compiler.
///
///
/// This task is intended for version 13.00.9466 of cl.exe.
///
///
/// Compiles helloworld.cpp for the Common Language Runtime.
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("cl")]
public class ClTask : ExternalProgramBase {
#region Private Instance Fields
private string _responseFileName;
private DirectoryInfo _outputDir;
private string _pchFile;
private PrecompiledHeaderMode _precompileHeaderMode = PrecompiledHeaderMode.Use;
private string _pchThroughFile;
private FileSet _sources = new FileSet();
private FileSet _includeDirs = new FileSet();
private FileSet _metaDataIncludeDirs = new FileSet();
private FileSet _forcedUsingFiles = new FileSet();
private bool _managedExtensions;
private CharacterSet _characterSet = CharacterSet.NotSet;
private string _options;
private OptionCollection _defines = new OptionCollection();
private OptionCollection _undefines = new OptionCollection();
private string _objectFile;
private string _pdbFile;
private Hashtable _resolvedIncludes;
private Regex _includeRegex;
private StringCollection _dirtySources = new StringCollection();
#endregion Private Instance Fields
#region Public Instance Constructors
///
/// Initializes a new instance of the class.
///
public ClTask() {
_resolvedIncludes = CollectionsUtil.CreateCaseInsensitiveHashtable();
_includeRegex = new Regex("^[\\s]*#include[\\s]*[\"<](?'includefile'[^\">]+)[\">][\\S\\s]*$");
}
#endregion Public Instance Constructors
#region Public Instance Properties
///
/// Directory where all output files are placed.
///
[TaskAttribute("outputdir", Required=true)]
public DirectoryInfo OutputDir {
get { return _outputDir; }
set { _outputDir = value; }
}
///
/// Specifies the path and/or name of the generated precompiled header
/// file - given either relative to or as an
/// absolute path.
///
[TaskAttribute("pchfile")]
public string PchFile {
get { return (_pchFile != null) ? Path.Combine(OutputDir.FullName, _pchFile) : null; }
set { _pchFile = StringUtils.ConvertEmptyToNull(value); }
}
///
/// The path of the boundary file when generating/using the
/// specified . If a precompiled header file is
/// not specified then this attribute is ignored.
///
[TaskAttribute("pchthroughfile")]
public string PchThroughFile {
get { return _pchThroughFile; }
set { _pchThroughFile = StringUtils.ConvertEmptyToNull(value); }
}
///
/// The mode in which the specified (if any) is
/// used. The default is .
///
[TaskAttribute("pchmode")]
public PrecompiledHeaderMode PchMode {
get { return _precompileHeaderMode; }
set {
if (!Enum.IsDefined(typeof(PrecompiledHeaderMode), value)) {
throw new ArgumentException(string.Format(
CultureInfo.InvariantCulture,
"An invalid type {0} was specified.", value));
} else {
_precompileHeaderMode = value;
}
}
}
///
/// Specifies whether Managed Extensions for C++ should be enabled.
/// The default is .
///
[TaskAttribute("managedextensions")]
[BooleanValidator()]
public bool ManagedExtensions {
get { return _managedExtensions; }
set { _managedExtensions = value;}
}
///
/// Tells the compiler to use the specified character set.
///
[TaskAttribute("characterset", Required=false)]
public CharacterSet CharacterSet {
get { return _characterSet; }
set {
if (!Enum.IsDefined(typeof(CharacterSet), value)) {
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture,
"An invalid character set '{0}' was specified.", value));
} else {
this._characterSet = value;
}
}
}
///
/// Options to pass to the compiler.
///
[TaskAttribute("options")]
public string Options {
get { return _options; }
set { _options = value; }
}
///
/// The list of files to compile.
///
[BuildElement("sources")]
public FileSet Sources {
get { return _sources; }
set { _sources = value; }
}
///
/// The list of directories in which to search for include files.
///
[BuildElement("includedirs")]
public FileSet IncludeDirs {
get { return _includeDirs; }
set { _includeDirs = value; }
}
///
/// Directories that the compiler will search to resolve file references
/// passed to the #using directive.
///
[BuildElement("metadataincludedirs")]
public FileSet MetaDataIncludeDirs {
get { return _metaDataIncludeDirs; }
set { _metaDataIncludeDirs = value; }
}
///
/// Specifies metadata files to reference in this compilation as an
/// alternative to passing a file name to #using in source code.
///
[BuildElement("forcedusingfiles")]
public FileSet ForcedUsingFiles {
get { return _forcedUsingFiles; }
set { _forcedUsingFiles = value; }
}
///
/// Macro definitions to pass to cl.exe.
/// Each entry will generate a /D
///
[BuildElementCollection("defines", "define")]
public OptionCollection Defines {
get { return _defines; }
}
///
/// Macro undefines (/U) to pass to cl.exe.
///
[BuildElementCollection("undefines", "undefine")]
public OptionCollection Undefines {
get { return _undefines; }
}
///
/// A name to override the default object file name; can be either a file
/// or directory name. The default is the output directory.
///
[TaskAttribute("objectfile")]
public string ObjectFile {
get { return (_objectFile != null ? Path.Combine(OutputDir.FullName, _objectFile) : OutputDir.FullName + "/"); }
set { _objectFile = StringUtils.ConvertEmptyToNull(value); }
}
///
/// A name for the compiler-generated PDB file; can be either a file or
/// directory name. The default is the output directory.
///
[TaskAttribute("pdbfile")]
public string ProgramDatabaseFile {
get { return (_pdbFile != null ? Path.Combine(OutputDir.FullName, _pdbFile) : OutputDir.FullName + "/"); }
set { _pdbFile = StringUtils.ConvertEmptyToNull(value); }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Gets the filename of the external program to start.
///
/// The filename of the external program.
public override string ProgramFileName {get {return Name;}}
///
/// Gets the command-line arguments for the external program.
///
///
/// The command-line arguments for the external program.
///
public override string ProgramArguments {
get { return "@" + "\"" + _responseFileName + "\""; }
}
#endregion Override implementation of ExternalProgramBase
#region Override implementation of Task
///
/// Compiles the sources.
///
protected override void ExecuteTask() {
// ensure base directory is set, even if fileset was not initialized
// from XML
if (Sources.BaseDirectory == null) {
Sources.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (IncludeDirs.BaseDirectory == null) {
IncludeDirs.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (MetaDataIncludeDirs.BaseDirectory == null) {
MetaDataIncludeDirs.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (ForcedUsingFiles.BaseDirectory == null) {
ForcedUsingFiles.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (NeedsCompiling()) {
Log(Level.Info, "Compiling {0} files to '{1}'.",
_dirtySources.Count, OutputDir.FullName);
// create temp response file to hold compiler options
_responseFileName = Path.GetTempFileName();
StreamWriter writer = new StreamWriter(_responseFileName);
try {
// write basic switches
writer.WriteLine("/c"); // compile only
if (Options != null) {
// write user defined options
writer.WriteLine(Options);
}
if (ManagedExtensions) {
// enables Managed Extensions for C++
writer.WriteLine("/clr");
}
// write preprocesser define(s)
foreach (Option define in Defines) {
if (!define.IfDefined || define.UnlessDefined) {
continue;
}
if (define.Value == null) {
writer.WriteLine("/D " + QuoteArgumentValue(define.OptionName));
} else {
writer.WriteLine("/D " + QuoteArgumentValue(define.OptionName
+ "=" + ArgumentUtils.DuplicateTrailingBackslash(define.Value)));
}
}
// write preprocesser undefine(s)
foreach (Option undefine in Undefines) {
if (!undefine.IfDefined || undefine.UnlessDefined) {
continue;
}
writer.WriteLine("/U " + QuoteArgumentValue(undefine.OptionName));
}
// write user provided include directories
foreach (string include in IncludeDirs.DirectoryNames) {
writer.WriteLine("/I {0}", QuoteArgumentValue(include));
}
// write directories that the compiler will search to resolve
// file references passed to the #using directive
foreach (string metaDataIncludeDir in MetaDataIncludeDirs.DirectoryNames) {
writer.WriteLine("/AI {0}", QuoteArgumentValue(metaDataIncludeDir));
}
// writes metadata files to reference in this compilation
// as an alternative to passing a file name to #using in
// source code
foreach (string forcedUsingFile in ForcedUsingFiles.FileNames) {
writer.WriteLine("/FU {0}", QuoteArgumentValue(forcedUsingFile));
}
// program database file
writer.WriteLine("/Fd{0}", QuoteArgumentValue(ProgramDatabaseFile));
// the object file or output directory
writer.WriteLine("/Fo{0}", QuoteArgumentValue(ObjectFile));
// specify pch file, if user specified one
if (PchFile != null) {
writer.WriteLine("/Fp{0}", QuoteArgumentValue(PchFile));
switch (PchMode) {
case PrecompiledHeaderMode.Use:
writer.Write("/Yu");
break;
case PrecompiledHeaderMode.Create:
writer.Write("/Yc");
break;
case PrecompiledHeaderMode.AutoCreate:
writer.Write("/YX");
break;
}
if (PchThroughFile != null) {
writer.WriteLine("{0}", QuoteArgumentValue(PchThroughFile));
}
}
// write each of the filenames
foreach (string filename in _dirtySources) {
writer.WriteLine(QuoteArgumentValue(filename));
}
// tell compiler which character set to use
switch (CharacterSet) {
case CharacterSet.Unicode:
writer.WriteLine("/D \"_UNICODE\"");
writer.WriteLine("/D \"UNICODE\"");
break;
case CharacterSet.MultiByte:
writer.WriteLine("/D \"_MBCS\"");
break;
}
writer.Close();
if (Verbose) {
// display response file contents
Log(Level.Info, "Contents of {0}.", _responseFileName);
StreamReader reader = File.OpenText(_responseFileName);
Log(Level.Info, reader.ReadToEnd());
reader.Close();
}
// suppresses display of the sign-on banner
// (this has no effect in response file)
this.Arguments.Add(new Argument("/nologo"));
// call base class to do the actual work
base.ExecuteTask();
} finally {
// make sure we delete response file even if an exception is thrown
writer.Close(); // make sure stream is closed or file cannot be deleted
File.Delete(_responseFileName);
_responseFileName = null;
}
}
}
#endregion Override implementation of Task
#region Protected Instance Methods
///
/// Determines if the sources need to be compiled.
///
protected virtual bool NeedsCompiling() {
if (!IsPchfileUpToDate()) {
// if pch file is not up-to-date, then mark all sources as dirty
Log(Level.Verbose, "PCH out of date, recompiling all sources.");
_dirtySources = StringUtils.Clone(Sources.FileNames);
return true;
}
return !AreObjsUpToDate();
}
#endregion Protected Instance Methods
#region Private Instance Methods
///
/// Determines whether the precompiled header file is up-to-date.
///
///
/// if no precompiled header file was specified;
/// otherwise, .
///
///
/// In order to determine accurately whether the precompile header file
/// is up-to-date, we'd need scan all the header files that are pulled
/// in. As this is not implemented right now, its safer to always
/// recompile.
///
private bool IsPchfileUpToDate() {
// TODO: also check for updated metadata includes (#using directives)
// if no pch file, then then it is theoretically up to date
if (PchFile == null) {
return true;
}
// if pch file declared, but doesn't exist, it must be stale
FileInfo pchFileInfo = new FileInfo(PchFile);
if (!pchFileInfo.Exists) {
Log(Level.Verbose, "'{0}' does not exist, recompiling.",
pchFileInfo.FullName);
return false;
}
// if an existing pch file is used, then pch file must never be
// recompiled
if (PchMode == PrecompiledHeaderMode.Use) {
return true;
}
// check if sources fresher than pch file
string fileName = FileSet.FindMoreRecentLastWriteTime(Sources.FileNames, pchFileInfo.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' is newer than pch file, recompiling.",
fileName);
return false;
}
// check if assembly references are fresher than pch file
fileName = FileSet.FindMoreRecentLastWriteTime(ForcedUsingFiles.FileNames, pchFileInfo.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' is newer than pch file, recompiling.",
fileName);
return false;
}
// check if included headers in source are modified after pch was compiled
foreach (string sourceFile in Sources.FileNames) {
fileName = FindUpdatedInclude(sourceFile, pchFileInfo.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, recompiling.",
fileName);
return false;
}
}
return true;
}
private bool IsObjUpToDate(string srcFileName) {
// TODO: also check for updated metadata includes (#using directives)
FileInfo objFileInfo = new FileInfo(GetObjOutputFile(srcFileName,
ObjectFile));
// if obj file doesn't exist, it must be stale
if (!objFileInfo.Exists) {
Log(Level.Verbose, "'{0}' does not exist, recompiling.",
objFileInfo.FullName);
return false;
}
// if obj file is older than the source file, it is stale
string fileName = FileSet.FindMoreRecentLastWriteTime(srcFileName, objFileInfo.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, recompiling.",
fileName);
return false;
}
// check if assembly references are fresher than pch file
fileName = FileSet.FindMoreRecentLastWriteTime(ForcedUsingFiles.FileNames, objFileInfo.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, recompiling.",
fileName);
return false;
}
// check if included headers in source are modified after obj was compiled
fileName = FindUpdatedInclude(srcFileName, objFileInfo.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, recompiling.",
fileName);
return false;
}
if (PchFile != null && PchMode == PrecompiledHeaderMode.Use) {
// check if precompiled header is modified after obj was compiled
fileName = FileSet.FindMoreRecentLastWriteTime(PchFile, objFileInfo.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, recompiling.",
fileName);
return false;
}
}
return true;
}
private bool AreObjsUpToDate() {
foreach (string filename in Sources.FileNames) {
// if the source file does not exist, then we'll consider it
// not up-to-date
if (!File.Exists(filename)) {
Log(Level.Verbose, "'{0}' does not exist, recompiling.",
filename);
_dirtySources.Add(filename);
continue;
}
if (!IsObjUpToDate(filename)) {
_dirtySources.Add(filename);
continue;
}
}
// if there are no outdated files, then the OBJs are up to date
return _dirtySources.Count == 0;
}
///
/// Determines whether any file that are includes in the specified
/// source file has been updated after the obj was compiled.
///
/// The source file to check.
/// The last write time of the compiled obj.
///
/// The full path to the include file that was modified after the obj
/// was compiled, or if no include files were
/// modified since the obj was compiled.
///
///
///
/// To determine what includes are defined in a source file, conditional
/// directives are not honored.
///
///
/// If a given include cannot be resolved to an existing file, then
/// it will be considered stable.
///
///
private string FindUpdatedInclude(string srcFileName, DateTime objLastWriteTime) {
// quick and dirty code to check whether includes have been modified
// after the source was last modified
// TODO: recursively check includes
Log(Level.Debug, "Checking whether includes of \"{0}\" have been"
+ " updated.", srcFileName);
// holds the line we're parsing
string line;
// locate include directives in source file
using (StreamReader sr = new StreamReader(srcFileName, true)) {
while ((line = sr.ReadLine()) != null) {
Match match = _includeRegex.Match(line);
if (match.Groups.Count != 2) {
continue;
}
string includeFile = match.Groups["includefile"].Value;
Log(Level.Debug, "Checking include \"{0}\"...", includeFile);
string resolvedInclude = _resolvedIncludes[includeFile] as string;
if (resolvedInclude == null) {
foreach (string includeDir in IncludeDirs.DirectoryNames) {
string foundIncludeFile = FileUtils.CombinePaths(includeDir, includeFile);
if (File.Exists(foundIncludeFile)) {
Log(Level.Debug, "Found include \"{0}\" in"
+ " includedirs.", includeFile);
resolvedInclude = foundIncludeFile;
break;
}
}
// if we could not locate include in include dirs and
// source dir, then try to locate include in INCLUDE
// env var
if (resolvedInclude == null) {
PathScanner pathScanner = new PathScanner();
pathScanner.Add(includeFile);
StringCollection includes = pathScanner.Scan("INCLUDE");
if (includes.Count > 0) {
Log(Level.Debug, "Found include \"{0}\" in"
+ " INCLUDE.", includeFile);
resolvedInclude = includes[0];
}
}
// if we could not locate include in include dirs
// and INCLUDE env var then check for include in base
// directory (which is used as working dir)
if (resolvedInclude == null) {
string foundIncludeFile = FileUtils.CombinePaths(
BaseDirectory.FullName, includeFile);
if (File.Exists(foundIncludeFile)) {
Log(Level.Debug, "Found include \"{0}\" in"
+ " working directory.", includeFile);
resolvedInclude = foundIncludeFile;
}
}
if (resolvedInclude != null) {
_resolvedIncludes.Add(includeFile, resolvedInclude);
}
}
if (resolvedInclude != null) {
if (File.GetLastWriteTime(resolvedInclude) > objLastWriteTime) {
return resolvedInclude;
}
} else {
// TODO: what do we do if the include cannot be located ?
//
// for now we'll consider the obj file to be up-to-date
Log(Level.Debug, "Include \"{0}\" could not be located.",
includeFile);
}
}
}
return null;
}
#endregion Private Instance Methods
#region Public Static Methods
///
/// Quotes an argument value and duplicates trailing backslahes.
///
/// The argument value to quote.
///
/// The quotes argument value.
///
public static string QuoteArgumentValue(string value) {
return ArgumentUtils.QuoteArgumentValue(value,
BackslashProcessingMethod.Duplicate);
}
///
/// Determines the file name of the OBJ file for the specified source
/// file.
///
/// The source file for which the OBJ file should be determined.
/// The path of the object file.
///
/// The file name of the OBJ file for the specified source file.
///
public static string GetObjOutputFile(string srcFile, string objectPath) {
if (srcFile == null) {
throw new ArgumentNullException("srcFile");
}
if (objectPath == null) {
throw new ArgumentNullException("objectPath");
}
// check if objectPath is file
if (!objectPath.EndsWith("/") && Path.GetFileName(objectPath).Length != 0) {
// if object file has no extension then use .obj, otherwise
// use objectPath as is
if (Path.GetExtension(objectPath).Length == 0) {
return Path.ChangeExtension(objectPath, ".obj");
} else {
return objectPath;
}
} else {
return FileUtils.CombinePaths(objectPath,
Path.GetFileNameWithoutExtension(srcFile) + ".obj");
}
}
#endregion Public Static Methods
///
/// Defines the supported modes for the use of precompiled header files.
///
public enum PrecompiledHeaderMode : int {
///
/// Create a precompiled header file.
///
///
/// For further information on the use of this option
/// see the Microsoft documentation on the C++ compiler flag /Yc.
///
Create = 1,
///
/// Automatically create a precompiled header file if necessary.
///
///
/// For further information on the use of this option
/// see the Microsoft documentation on the C++ compiler flag /YX.
///
AutoCreate = 2,
///
/// Use a (previously generated) precompiled header file.
///
///
/// For further information on the use of this option
/// see the Microsoft documentation on the C++ compiler flag /Yu.
///
Use = 0
}
}
}
#if unused
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.00.9466 for 80x86
Copyright (C) Microsoft Corporation 1984-2001. All rights reserved.
C/C++ COMPILER OPTIONS
-OPTIMIZATION-
/O1 minimize space /Op[-] improve floating-pt consistency
/O2 maximize speed /Os favor code space
/Oa assume no aliasing /Ot favor code speed
/Ob inline expansion (default n=0) /Ow assume cross-function aliasing
/Od disable optimizations (default) /Ox maximum opts. (/Ogityb2 /Gs)
/Og enable global optimization /Oy[-] enable frame pointer omission
/Oi enable intrinsic functions
-CODE GENERATION-
/G3 optimize for 80386 /GH enable _pexit function call
/G4 optimize for 80486 /GR[-] enable C++ RTTI
/G5 optimize for Pentium /GX[-] enable C++ EH (same as /EHsc)
/G6 optimize for PPro, P-II, P-III /EHs enable C++ EH (no SEH exceptions)
/GB optimize for blended model (default) /EHa enable C++ EH (w/ SEH exceptions)
/Gd __cdecl calling convention /EHc extern "C" defaults to nothrow
/Gr __fastcall calling convention /GT generate fiber-safe TLS accesses
/Gz __stdcall calling convention /Gm[-] enable minimal rebuild
/GA optimize for Windows Application /GL[-] enable link-time code generation
/Gf enable string pooling /QIfdiv[-] enable Pentium FDIV fix
/GF enable read-only string pooling /QI0f[-] enable Pentium 0x0f fix
/Gy separate functions for linker /QIfist[-] use FIST instead of ftol()
/GZ Enable stack checks (/RTCs) /RTC1 Enable fast checks (/RTCsu)
/Ge force stack checking for all funcs /RTCc Convert to smaller type checks
/Gs[num] control stack checking calls /RTCs Stack Frame runtime checking
/GS enable security checks /RTCu Uninitialized local usage checks
/Gh enable _penter function call
/clr[:noAssembly] compile for the common language runtime
noAssembly - do not produce an assembly
-OUTPUT FILES-
/Fa[file] name assembly listing file /Fo name object file
/FA[sc] configure assembly listing /Fp name precompiled header file
/Fd[file] name .PDB file /Fr[file] name source browser file
/Fe name executable file /FR[file] name extended .SBR file
/Fm[file] name map file
-PREPROCESSOR-
/AI add to assembly search path /Fx merge injected code to file
/FU forced using assembly/module /FI name forced include file
/C don't strip comments /U remove predefined macro
/D{=|#} define macro /u remove all predefined macros
/E preprocess to stdout /I add to include search path
/EP preprocess to stdout, no #line /X ignore "standard places"
/P preprocess to file
-LANGUAGE-
/Zi enable debugging information /Zl omit default library name in .OBJ
/ZI enable Edit and Continue debug info /Zg generate function prototypes
/Z7 enable old-style debug info /Zs syntax check only
/Zd line number debugging info only /vd{0|1} disable/enable vtordisp
/Zp[n] pack structs on n-byte boundary /vm type of pointers to members
/Za disable extensions (implies /Op) /noBool disable "bool" keyword
/Ze enable extensions (default)
/Zc:arg1[,arg2] C++ language conformance, where arguments can be:
forScope - enforce Standard C++ for scoping rules
wchar_t - wchar_t is the native type, not a typedef
-MISCELLANEOUS-
@ options response file /wo issue warning n once
/?, /help print this help message /w set warning level 1-4 for n
/c compile only, no link /W set warning level (default n=1)
/H max external name length /Wall enable all warnings
/J default char type is unsigned /Wp64 enable 64 bit porting warnings
/nologo suppress copyright message /WX treat warnings as errors
/showIncludes show include file names /WL enable one line diagnostics
/Tc compile file as .c /Yc[file] create .PCH file
/Tp compile file as .cpp /Yd put debug info in every .OBJ
/TC compile all files as .c /Yl[sym] inject .PCH ref for debug lib
/TP compile all files as .cpp /Yu[file] use .PCH file
/V set version string /YX[file] automatic .PCH
/w disable all warnings /Y- disable all PCH options
/wd disable warning n /Zm max memory alloc (% of default)
/we treat warning n as an error
-LINKING-
/MD link with MSVCRT.LIB /MDd link with MSVCRTD.LIB debug lib
/ML link with LIBC.LIB /MLd link with LIBCD.LIB debug lib
/MT link with LIBCMT.LIB /MTd link with LIBCMTD.LIB debug lib
/LD Create .DLL /F set stack size
/LDd Create .DLL debug library /link [linker options and libraries]
#endif
nant-0.92-rc1/src/NAnt.VisualCpp/Tasks/MidlTask.cs 0000644 0001750 0001750 00000037642 11757302274 021525 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
// original author unknown
// Ian MacLean (ian_maclean@another.com)
// Hani Atassi (haniatassi@users.sourceforge.net)
using System;
using System.IO;
using System.Text;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.VisualCpp.Util;
namespace NAnt.VisualCpp.Tasks {
///
/// This tasks allows you to run MIDL.exe.
///
///
///
/// This task only supports a small subset of the MIDL.EXE command line
/// switches, but you can use the options element to specify any other
/// unsupported commands you want to specify.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("midl")]
public class MidlTask : ExternalProgramBase {
#region Private Instance Fields
private string _responseFileName;
private string _acf;
private string _align;
private bool _appConfig;
private string _char;
private string _client;
private string _cstub;
// TODO: /D!!!!!
private FileInfo _dlldata;
private string _env = "win32";
// TODO: /error
private string _Oi;
private FileInfo _header;
private FileInfo _iid;
private FileInfo _proxy;
private FileInfo _tlb;
private FileInfo _filename;
private OptionCollection _options = new OptionCollection();
private OptionCollection _defines = new OptionCollection();
private OptionCollection _undefines = new OptionCollection();
private FileSet _includeDirs = new FileSet();
#endregion Private Instance Fields
#region Private Static Fields
private const string PROG_FILE_NAME = "midl.exe";
#endregion Private Static Fields
#region Public Instance Properties
///
/// The /acf switch allows the user to supply an
/// explicit ACF file name. The switch also
/// allows the use of different interface names in
/// the IDL and ACF files.
///
[TaskAttribute("acf")]
public string Acf {
get { return _acf; }
set { _acf = value; }
}
///
/// The /align switch is functionally the same as the
/// MIDL /Zp option and is recognized by the MIDL compiler
/// solely for backward compatibility with MkTypLib.
///
/// The alignment value can be 1, 2, 4, or 8.
[TaskAttribute("align")]
public string Align {
get { return _align; }
set { _align = value; }
}
///
/// The /app_config switch selects application-configuration
/// mode, which allows you to use some ACF keywords in the
/// IDL file. With this MIDL compiler switch, you can omit
/// the ACF and specify an interface in a single IDL file.
///
[TaskAttribute("app_config"), BooleanValidator()]
public bool AppConfig {
get { return _appConfig; }
set { _appConfig = value; }
}
///
/// The /char switch helps to ensure that the MIDL compiler
/// and C compiler operate together correctly for all char
/// and small types.
///
/// Can be one of signed | unsigned | ascii7
[TaskAttribute("char")]
public string Char {
get { return _char; }
set { _char = value; }
}
///
/// The /client switch directs the MIDL compiler to generate
/// client-side C source files for an RPC interface
///
/// can be one of stub | none
[TaskAttribute("client")]
public string Client {
get { return _client; }
set { _client = value; }
}
///
/// The /cstub switch specifies the name of the client
/// stub file for an RPC interface.
///
[TaskAttribute("cstub")]
public string CStub {
get { return _cstub; }
set { _cstub = value; }
}
///
/// Specifies the file name for the generated dlldata file for a proxy
/// DLL. The default file name Dlldata.c is used if
/// is not specified.
///
[TaskAttribute("dlldata")]
public FileInfo DllData {
get { return _dlldata; }
set { _dlldata = value; }
}
///
/// The /env switch selects the
/// environment in which the application runs.
///
/// It can take the values win32 and win64
[TaskAttribute("env")]
public string Env {
get { return _env; }
set { _env = value; }
}
///
/// The /Oi switch directs the MIDL compiler to
/// use a fully-interpreted marshaling method.
/// The /Oic and /Oicf switches provide additional
/// performance enhancements.
///
///
/// If you specify the Oi attribute, you must set it to
/// one of the values:
/// - Oi=""
/// - Oi="c"
/// - Oi="f"
/// - Oi="cf"
///
[TaskAttribute("Oi")]
public string Oi {
get { return _Oi; }
set { _Oi = value; }
}
///
/// Specifies a file name for the type library generated by the MIDL
/// compiler.
///
[TaskAttribute("tlb")]
public FileInfo Tlb {
get { return _tlb; }
set { _tlb = value; }
}
///
/// Specifies the name of the header file.
///
[TaskAttribute("header")]
public FileInfo Header {
get { return _header; }
set { _header = value; }
}
///
/// Specifies the name of the interface identifier file for a COM
/// interface, overriding the default name obtained by adding _i.c
/// to the IDL file name.
///
[TaskAttribute("iid")]
public FileInfo Iid {
get { return _iid; }
set { _iid = value; }
}
///
/// Specifies the name of the interface proxy file for a COM interface.
///
[TaskAttribute("proxy")]
public FileInfo Proxy {
get { return _proxy; }
set { _proxy = value; }
}
///
/// Name of .IDL file to process.
///
[TaskAttribute("filename", Required=true)]
public FileInfo Filename {
get { return _filename; }
set { _filename = value; }
}
///
/// Additional options to pass to midl.exe.
///
[BuildElementCollection("options", "option")]
public OptionCollection Options {
get { return _options; }
}
///
/// Macro definitions to pass to mdil.exe.
/// Each entry will generate a /D
///
[BuildElementCollection("defines", "define")]
public OptionCollection Defines {
get { return _defines; }
}
///
/// Macro undefines (/U) to pass to mdil.
///
[BuildElementCollection("undefines", "undefine")]
public OptionCollection Undefines {
get { return _undefines; }
}
///
/// The list of directories in which to search for include files.
///
[BuildElement("includedirs")]
public FileSet IncludeDirs {
get { return _includeDirs; }
set { _includeDirs = value; }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Filename of program to execute
///
public override string ProgramFileName {
get { return PROG_FILE_NAME; }
}
///
/// Gets the command-line arguments for the external program.
///
///
/// The command-line arguments for the external program.
///
public override string ProgramArguments {
get { return "@" + "\"" + _responseFileName + "\""; }
}
///
/// This is where the work is done.
///
protected override void ExecuteTask() {
if (IncludeDirs.BaseDirectory == null) {
IncludeDirs.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (NeedsCompiling()) {
// create temp response file to hold compiler options
_responseFileName = Path.GetTempFileName();
try {
using (StreamWriter writer = new StreamWriter(_responseFileName)) {
WriteResponseFile(writer);
}
if (Verbose) {
// display response file contents
Log(Level.Info, "Contents of " + _responseFileName);
StreamReader reader = File.OpenText(_responseFileName);
Log(Level.Info, reader.ReadToEnd());
reader.Close();
}
base.ExecuteTask();
} finally {
// make sure we delete the response file
File.Delete(_responseFileName);
_responseFileName = null;
}
}
}
#endregion Override implementation of ExternalProgramBase
#region Private Instance Methods
///
/// Check output files to see if we need rebuilding.
///
/// if a rebuild is needed; otherwise,
/// .
private bool NeedsCompiling() {
if (Tlb != null && NeedsCompiling(Tlb)) {
return true;
} else if (Header != null && NeedsCompiling(Header)) {
return true;
} else if (Iid != null && NeedsCompiling(Iid)) {
return true;
}
// up-to-date check for proxy and dlldata should not be performed,
// as, even though specified, the compiler might not output these
// files (why ? no idea)
return false;
}
///
/// Check output files to see if we need rebuilding.
///
///
/// if a rebuild is needed; otherwise,
/// .
///
private bool NeedsCompiling(FileInfo outputFile) {
if (!outputFile.Exists) {
Log(Level.Verbose, "Output file '{0}' does not exist, recompiling.",
outputFile.FullName);
return true;
}
string fileName = FileSet.FindMoreRecentLastWriteTime(Filename.FullName,
outputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' is out of date, recompiling.", fileName);
return true;
}
return false;
}
///
/// Writes the response file for midl.exe.
///
private void WriteResponseFile(TextWriter writer) {
// suppresses display of the sign-on banner
writer.WriteLine("/nologo");
writer.WriteLine("/env " + _env);
if (_acf != null)
writer.WriteLine("/acf {0}", _acf);
if (_align != null)
writer.WriteLine("/align {0}", _align);
if (_appConfig)
writer.WriteLine("/app_config");
if (_char != null)
writer.WriteLine("/char {0}", _char);
if (_client != null)
writer.WriteLine("/client {0}", _client);
if (_cstub != null)
writer.WriteLine("/cstub {0}", _cstub);
if (_dlldata != null) {
writer.WriteLine("/dlldata \"{0}\"", DllData.FullName);
}
if (_Oi != null)
writer.WriteLine("/Oi" + _Oi);
if (Tlb != null)
writer.WriteLine("/tlb \"{0}\"", Tlb.FullName);
if (_header != null)
writer.WriteLine("/header \"{0}\"", Header.FullName);
if (Iid != null)
writer.WriteLine("/iid \"{0}\"", Iid.FullName);
if (Proxy != null)
writer.WriteLine("/proxy \"{0}\"", Proxy.FullName);
foreach (Option define in Defines) {
if (!define.IfDefined || define.UnlessDefined) {
continue;
}
if (define.Value == null) {
writer.WriteLine("/D " + ArgumentUtils.FixTrailingBackslash(define.OptionName));
} else {
writer.WriteLine("/D " + define.OptionName + "=" + ArgumentUtils.FixTrailingBackslash(define.Value));
}
}
foreach (Option undefine in Undefines) {
if (!undefine.IfDefined || undefine.UnlessDefined) {
continue;
}
writer.WriteLine("/U " + ArgumentUtils.QuoteArgumentValue(
undefine.OptionName, BackslashProcessingMethod.Fix));
}
foreach (Option option in _options) {
if (IfDefined && !UnlessDefined) {
if (option.Value == null) {
writer.WriteLine(option.OptionName);
} else {
writer.WriteLine(option.OptionName + " " + option.Value);
}
}
}
// append user provided include directories
foreach (string include in IncludeDirs.DirectoryNames) {
writer.WriteLine("/I {0}", ArgumentUtils.QuoteArgumentValue(
include, BackslashProcessingMethod.Clean));
}
writer.WriteLine("\"{0}\"", Filename.FullName);
}
#endregion Private Instance Methods
}
}
nant-0.92-rc1/src/NAnt.VisualCpp/Tasks/LinkTask.cs 0000644 0001750 0001750 00000040503 11757302274 021523 0 ustar jtaylor jtaylor // NAnt - A .NET build tool
// Copyright (C) 2001-2003 Gerry Shaw
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// Shawn Van Ness (nantluver@arithex.com)
// Gerry Shaw (gerry_shaw@yahoo.com)
// Ian MacLean (ian@maclean.ms)
// Eric V. Smith (ericsmith@windsor.com)
//
// TODO: review interface for future compatibility/customizations issues
using System;
using System.IO;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
using NAnt.Core.Types;
using NAnt.Core.Util;
using NAnt.VisualCpp.Types;
using NAnt.VisualCpp.Util;
namespace NAnt.VisualCpp.Tasks {
///
/// Links files using link.exe, Microsoft's Incremental Linker.
///
///
/// This task is intended for version 7.00.9466 of link.exe.
///
///
///
/// Combine all object files in the current directory into helloworld.exe.
///
///
///
///
///
///
///
/// ]]>
///
///
[TaskName("link")]
public class LinkTask : ExternalProgramBase {
#region Private Instance Fields
private string _responseFileName;
private FileInfo _outputFile;
private FileInfo _pdbFile;
private FileInfo _moduleDefinition;
private bool _debug;
private FileSet _sources = new FileSet();
private FileSet _libdirs = new FileSet();
private FileSet _modules = new FileSet();
private FileSet _delayLoadedDlls = new FileSet();
private FileSet _embeddedResources = new FileSet();
private SymbolCollection _symbols = new SymbolCollection();
private LibraryCollection _ignoreLibraries = new LibraryCollection();
private string _options;
#endregion Private Instance Fields
#region Public Instance Properties
///
/// Options to pass to the compiler.
///
[TaskAttribute("options")]
public string Options {
get { return _options; }
set { _options = value; }
}
///
/// Create debugging information for the .exe file or DLL. The default is
/// .
///
public bool Debug {
get { return _debug; }
set { _debug = value; }
}
///
/// The output file.
///
[TaskAttribute("output", Required=true)]
public FileInfo OutputFile {
get { return _outputFile; }
set { _outputFile = value; }
}
///
/// A user-specified name for the program database (PDB) that the linker
/// creates. The default file name for the PDB has the base name of the
/// and the extension .pdb.
///
[TaskAttribute("pdbfile")]
public FileInfo ProgramDatabaseFile {
get {
if (Debug && _pdbFile == null) {
_pdbFile = new FileInfo(Path.ChangeExtension(OutputFile.FullName, ".pdb"));
}
return _pdbFile;
}
set { _pdbFile = value; }
}
///
/// The name of a module-definition file (.def) to be passed to the
/// linker.
///
[TaskAttribute("moduledefinition")]
public FileInfo ModuleDefinition {
get { return _moduleDefinition; }
set { _moduleDefinition = value; }
}
///
/// Specified DLLs for delay loading.
///
[BuildElement("delayloaded")]
public FileSet DelayLoadedDlls {
get { return _delayLoadedDlls; }
set { _delayLoadedDlls = value; }
}
///
/// The list of files to combine into the output file.
///
[BuildElement("sources")]
public FileSet Sources {
get { return _sources; }
set { _sources = value; }
}
///
/// The list of additional library directories to search.
///
[BuildElement("libdirs")]
public FileSet LibDirs {
get { return _libdirs; }
set { _libdirs = value; }
}
///
/// Link the specified modules into this assembly.
///
[BuildElement("modules")]
public FileSet Modules {
get { return _modules; }
set { _modules = value; }
}
///
/// Embed the specified resources into this assembly.
///
[BuildElement("embeddedresources")]
public FileSet EmbeddedResources {
get { return _embeddedResources; }
set { _embeddedResources = value; }
}
///
/// Symbols to add to the symbol table.
///
[BuildElementCollection("symbols", "symbol")]
public SymbolCollection Symbols {
get { return _symbols; }
set { _symbols = value; }
}
///
/// Names of libraries that you want the linker to ignore when it
/// resolves external references.
///
[BuildElementCollection("ignorelibraries", "library")]
public LibraryCollection IgnoreLibraries {
get { return _ignoreLibraries; }
set { _ignoreLibraries = value; }
}
#endregion Public Instance Properties
#region Override implementation of ExternalProgramBase
///
/// Gets the filename of the external program to start.
///
/// The filename of the external program.
public override string ProgramFileName {
get { return Name; }
}
///
/// Gets the command-line arguments for the external program.
///
///
/// The command-line arguments for the external program.
///
public override string ProgramArguments {
get { return "@" + "\"" + _responseFileName + "\""; }
}
#endregion Override implementation of ExternalProgramBase
#region Override implementation of Task
///
/// Links the sources.
///
protected override void ExecuteTask() {
// ensure base directory is set, even if fileset was not initialized
// from XML
if (Sources.BaseDirectory == null) {
Sources.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (LibDirs.BaseDirectory == null) {
LibDirs.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (Modules.BaseDirectory == null) {
Modules.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (EmbeddedResources.BaseDirectory == null) {
EmbeddedResources.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (NeedsLinking()) {
Log(Level.Info, "Linking {0} files.",
Sources.FileNames.Count);
// create temp response file to hold compiler options
_responseFileName = Path.GetTempFileName();
StreamWriter writer = new StreamWriter(_responseFileName);
try {
// specify the output file
writer.WriteLine("/OUT:\"{0}\"", OutputFile.FullName);
// write user provided options
if (Options != null) {
writer.WriteLine(Options);
}
// module definition file
if (ModuleDefinition != null) {
writer.WriteLine("/DEF:\"{0}\"", ModuleDefinition.FullName);
}
// write each of the libdirs
foreach (string libdir in LibDirs.DirectoryNames) {
writer.WriteLine("/LIBPATH:{0}", QuoteArgumentValue(libdir));
}
// write each of the module references
foreach (string module in Modules.FileNames) {
writer.WriteLine("/ASSEMBLYMODULE:{0}", QuoteArgumentValue(module));
}
// write delay loaded DLLs
foreach (string dll in DelayLoadedDlls.FileNames) {
writer.WriteLine("/DELAYLOAD:{0}", QuoteArgumentValue(dll));
}
// write each of the embedded resources
foreach (string resource in EmbeddedResources.FileNames) {
writer.WriteLine("/ASSEMBLYRESOURCE:{0}", QuoteArgumentValue(resource));
}
// write symbols
foreach (Symbol symbol in Symbols) {
if (symbol.IfDefined && !symbol.UnlessDefined) {
writer.WriteLine("/INCLUDE:{0}", QuoteArgumentValue(
symbol.SymbolName));
}
}
// names of default libraries to ignore
foreach (Library ignoreLibrary in IgnoreLibraries) {
if (ignoreLibrary.IfDefined && !ignoreLibrary.UnlessDefined) {
writer.WriteLine("/NODEFAULTLIB:{0}", QuoteArgumentValue(
ignoreLibrary.LibraryName));
}
}
if (Debug) {
writer.WriteLine("/DEBUG");
}
// write program database file
if (ProgramDatabaseFile != null) {
writer.WriteLine("/PDB:{0}", QuoteArgumentValue(
ProgramDatabaseFile.FullName));
}
// suppresses display of the sign-on banner
writer.WriteLine("/nologo");
// write each of the filenames
foreach (string filename in Sources.FileNames) {
writer.WriteLine(QuoteArgumentValue(filename));
}
writer.Close();
if (Verbose) {
// display response file contents
Log(Level.Info, "Contents of {0}.", _responseFileName);
StreamReader reader = File.OpenText(_responseFileName);
Log(Level.Info, reader.ReadToEnd());
reader.Close();
}
// call base class to do the actual work
base.ExecuteTask();
} finally {
// make sure we delete response file even if an exception is thrown
writer.Close(); // make sure stream is closed or file cannot be deleted
File.Delete(_responseFileName);
_responseFileName = null;
}
}
}
#endregion Override implementation of Task
#region Protected Instance Methods
///
/// Determines if the output needs linking.
///
protected virtual bool NeedsLinking() {
string fileName;
// return true as soon as we know we need to compile
if (ProgramDatabaseFile != null) {
if (!ProgramDatabaseFile.Exists) {
Log(Level.Verbose, "PDB file '{0}' does not exist, relinking.",
ProgramDatabaseFile.FullName);
return true;
}
// check if sources were updated
fileName = FileSet.FindMoreRecentLastWriteTime(Sources.FileNames, ProgramDatabaseFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, relinking.", fileName);
return true;
}
}
if (!OutputFile.Exists) {
Log(Level.Verbose, "Output file '{0}' does not exist, relinking.",
OutputFile.FullName);
return true;
}
// check if sources were updated
fileName = FileSet.FindMoreRecentLastWriteTime(Sources.FileNames, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, "'{0}' has been updated, relinking.", fileName);
return true;
}
if (ModuleDefinition != null) {
fileName = FileSet.FindMoreRecentLastWriteTime(ModuleDefinition.FullName, OutputFile.LastWriteTime);
if (fileName != null) {
Log(Level.Verbose, ResourceUtils.GetString("String_FileHasBeenUpdated"),
fileName);
return true;
}
}
return false;
}
#endregion Protected Instance Methods
#region Public Static Methods
///
/// Quotes an argument value and duplicates trailing backslahes.
///
/// The argument value to quote.
///
/// The quotes argument value.
///
public static string QuoteArgumentValue(string value) {
return ArgumentUtils.QuoteArgumentValue(value,
BackslashProcessingMethod.Duplicate);
}
#endregion Public Static Methods
}
}
#if unused
Microsoft (R) Incremental Linker Version 7.00.9466
Copyright (C) Microsoft Corporation. All rights reserved.
usage: LINK [options] [files] [@commandfile]
options:
/ALIGN:#
/ALLOWBIND[:NO]
/ASSEMBLYMODULE:filename
/ASSEMBLYRESOURCE:filename
/BASE:{address|@filename,key}
/DEBUG
/DEF:filename
/DEFAULTLIB:library
/DELAY:{NOBIND|UNLOAD}
/DELAYLOAD:dll
/DLL
/DRIVER[:{UPONLY|WDM}]
/ENTRY:symbol
/EXETYPE:DYNAMIC
/EXPORT:symbol
/FIXED[:NO]
/FORCE[:{MULTIPLE|UNRESOLVED}]
/HEAP:reserve[,commit]
/IDLOUT:filename
/IGNOREIDL
/IMPLIB:filename
/INCLUDE:symbol
/INCREMENTAL[:NO]
/LARGEADDRESSAWARE[:NO]
/LIBPATH:dir
/LTCG[:{NOSTATUS|PGINSTRUMENT|PGOPTIMIZE|STATUS}]
(PGINSTRUMENT and PGOPTIMIZE are only available for IA64)
/MACHINE:{AM33|ARM|IA64|M32R|MIPS|MIPS16|MIPSFPU|MIPSFPU16|MIPSR41XX|
PPC|PPCFP|SH3|SH3DSP|SH4|SH5|THUMB|TRICORE|X86}
/MAP[:filename]
/MAPINFO:{EXPORTS|LINES}
/MERGE:from=to
/MIDL:@commandfile
/NOASSEMBLY
/NODEFAULTLIB[:library]
/NOENTRY
/NOLOGO
/OPT:{ICF[=iterations]|NOICF|NOREF|NOWIN98|REF|WIN98}
/ORDER:@filename
/OUT:filename
/PDB:filename
/PDBSTRIPPED:filename
/PGD:filename
/RELEASE
/SECTION:name,[E][R][W][S][D][K][L][P][X][,ALIGN=#]
/STACK:reserve[,commit]
/STUB:filename
/SUBSYSTEM:{CONSOLE|EFI_APPLICATION|EFI_BOOT_SERVICE_DRIVER|
EFI_ROM|EFI_RUNTIME_DRIVER|NATIVE|POSIX|WINDOWS|
WINDOWSCE}[,#[.##]]
/SWAPRUN:{CD|NET}
/TLBOUT:filename
/TSAWARE[:NO]
/TLBID:#
/VERBOSE[:LIB]
/VERSION:#[.#]
/VXD
/WINDOWSCE:{CONVERT|EMULATION}
/WS:AGGRESSIVE
#endif
nant-0.92-rc1/src/NAnt.VisualCpp/NAnt.VisualCpp.csproj 0000644 0001750 0001750 00000010707 11757302274 022361 0 ustar jtaylor jtaylor
DebugAnyCPU2.0{A154DB17-7263-44E3-838E-1E4C4946B7D8}NAnt.VisualCppNAnt.VisualCppTasksLibraryOnSuccessfulBuildfalse8.0.50727v2.02.0publish\trueDiskfalseForeground7Daysfalsefalsetrue01.0.0.%2afalsefalsetruetruefullfalse4..\..\build\Debug\AllRules.rulesetTRACE;DEBUG..\..\build\Debug\NAnt.VisualCppTasks.xmltruepdbonlytrue..\..\build\Release\4AllRules.rulesetTRACE..\..\build\Release\NAnt.VisualCppTasks.xml
CommonAssemblyInfo.cs
False.NET Framework 3.5 SP1 Client ProfilefalseFalse.NET Framework 3.5 SP1trueFalseWindows Installer 3.1true{8F5F8375-4097-4952-B860-784EB9961ABE}NAnt.Core nant-0.92-rc1/src/NAnt.VisualCpp/NAnt.VisualCpp.build 0000644 0001750 0001750 00000002255 11757302274 022157 0 ustar jtaylor jtaylor
Release Notes
Help
Help
Introduction
NUnit - Required for unit testing