Initial code commit

7 files changed, 858 insertions, 0 deletions

diff --git a/src/WixToolset.Core/Extensibility/AssemblyDefaultHeatExtensionAttribute.cs b/src/WixToolset.Core/Extensibility/AssemblyDefaultHeatExtensionAttribute.cs
new file mode 100644
index 00000000..bb53e30c
--- /dev/null
+++ b/src/WixToolset.Core/Extensibility/AssemblyDefaultHeatExtensionAttribute.cs
@@ -0,0 +1,33 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Tools
+{
+    using System;
+
+    /// <summary>
+    /// Represents a custom attribute for declaring the type to use
+    /// as the default heat extension in an assembly.
+    /// </summary>
+    public class AssemblyDefaultHeatExtensionAttribute : Attribute
+    {
+        private readonly Type extensionType;
+
+        /// <summary>
+        /// Instantiate a new AssemblyDefaultHeatExtensionAttribute.
+        /// </summary>
+        /// <param name="extensionType">The type of the default heat extension in an assembly.</param>
+        public AssemblyDefaultHeatExtensionAttribute(Type extensionType)
+        {
+            this.extensionType = extensionType;
+        }
+
+        /// <summary>
+        /// Gets the type of the default heat extension in an assembly.
+        /// </summary>
+        /// <value>The type of the default heat extension in an assembly.</value>
+        public Type ExtensionType
+        {
+            get { return this.extensionType; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Extensibility/HarvesterExtension.cs b/src/WixToolset.Core/Extensibility/HarvesterExtension.cs
new file mode 100644
index 00000000..d8d0ab34
--- /dev/null
+++ b/src/WixToolset.Core/Extensibility/HarvesterExtension.cs
@@ -0,0 +1,26 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset
+{
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// The base harvester extension.  Any of these methods can be overridden to change
+    /// the behavior of the harvester.
+    /// </summary>
+    public abstract class HarvesterExtension
+    {
+        /// <summary>
+        /// Gets or sets the harvester core for the extension.
+        /// </summary>
+        /// <value>The harvester core for the extension.</value>
+        public IHarvesterCore Core { get; set; }
+
+        /// <summary>
+        /// Harvest a WiX document.
+        /// </summary>
+        /// <param name="argument">The argument for harvesting.</param>
+        /// <returns>The harvested Fragments.</returns>
+        public abstract Wix.Fragment[] Harvest(string argument);
+    }
+}
diff --git a/src/WixToolset.Core/Extensibility/HeatExtension.cs b/src/WixToolset.Core/Extensibility/HeatExtension.cs
new file mode 100644
index 00000000..5e292220
--- /dev/null
+++ b/src/WixToolset.Core/Extensibility/HeatExtension.cs
@@ -0,0 +1,204 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Extensibility
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Reflection;
+    using WixToolset;
+    using WixToolset.Data;
+    using WixToolset.Extensibilty;
+    using WixToolset.Tools;
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// A command line option.
+    /// </summary>
+    public struct HeatCommandLineOption
+    {
+        public string Option;
+
+        public string Description;
+
+        /// <summary>
+        /// Instantiates a new CommandLineOption.
+        /// </summary>
+        /// <param name="option">The option name.</param>
+        /// <param name="description">The description of the option.</param>
+        public HeatCommandLineOption(string option, string description)
+        {
+            this.Option = option;
+            this.Description = description;
+        }
+    }
+
+    /// <summary>
+    /// An extension for the WiX Toolset Harvester application.
+    /// </summary>
+    public abstract class HeatExtension
+    {
+        /// <summary>
+        /// Gets or sets the heat core for the extension.
+        /// </summary>
+        /// <value>The heat core for the extension.</value>
+        public IHeatCore Core { get; set; }
+
+        /// <summary>
+        /// Gets the supported command line types for this extension.
+        /// </summary>
+        /// <value>The supported command line types for this extension.</value>
+        public virtual HeatCommandLineOption[] CommandLineTypes
+        {
+            get { return null; }
+        }
+
+        /// <summary>
+        /// Loads a HeatExtension from a type description string.
+        /// </summary>
+        /// <param name="extension">The extension type description string.</param>
+        /// <returns>The loaded HeatExtension.</returns>
+        /// <remarks>
+        /// <paramref name="extension"/> can be in several different forms:
+        /// <list type="number">
+        /// <item><term>AssemblyQualifiedName (TopNamespace.SubNameSpace.ContainingClass+NestedClass, MyAssembly, Version=1.3.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089)</term></item>
+        /// <item><term>AssemblyName (MyAssembly, Version=1.3.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089)</term></item>
+        /// <item><term>Absolute path to an assembly (C:\MyExtensions\ExtensionAssembly.dll)</term></item>
+        /// <item><term>Filename of an assembly in the application directory (ExtensionAssembly.dll)</term></item>
+        /// <item><term>Relative path to an assembly (..\..\MyExtensions\ExtensionAssembly.dll)</term></item>
+        /// </list>
+        /// To specify a particular class to use, prefix the fully qualified class name to the assembly and separate them with a comma.
+        /// For example: "TopNamespace.SubNameSpace.ContainingClass+NestedClass, C:\MyExtensions\ExtensionAssembly.dll"
+        /// </remarks>
+        public static HeatExtension Load(string extension)
+        {
+            Type extensionType = null;
+            int commaIndex = extension.IndexOf(',');
+            string className = String.Empty;
+            string assemblyName = extension;
+
+            if (0 <= commaIndex)
+            {
+                className = extension.Substring(0, commaIndex);
+                assemblyName = (extension.Length <= commaIndex + 1 ? String.Empty : extension.Substring(commaIndex + 1));
+            }
+
+            className = className.Trim();
+            assemblyName = assemblyName.Trim();
+
+            if (null == extensionType && 0 < assemblyName.Length)
+            {
+
+                Assembly extensionAssembly;
+
+                // case 3: Absolute path to an assembly
+                if (Path.IsPathRooted(assemblyName))
+                {
+                    extensionAssembly = ExtensionLoadFrom(assemblyName);
+                }
+                else
+                {
+                    try
+                    {
+                        // case 2: AssemblyName
+                        extensionAssembly = Assembly.Load(assemblyName);
+                    }
+                    catch (IOException e)
+                    {
+                        if (e is FileLoadException || e is FileNotFoundException)
+                        {
+                            try
+                            {
+                                // case 4: Filename of an assembly in the application directory
+                                extensionAssembly = Assembly.Load(Path.GetFileNameWithoutExtension(assemblyName));
+                            }
+                            catch (IOException innerE)
+                            {
+                                if (innerE is FileLoadException || innerE is FileNotFoundException)
+                                {
+                                    // case 5: Relative path to an assembly
+
+                                    // we want to use Assembly.Load when we can because it has some benefits over Assembly.LoadFrom
+                                    // (see the documentation for Assembly.LoadFrom). However, it may fail when the path is a relative
+                                    // path, so we should try Assembly.LoadFrom one last time. We could have detected a directory
+                                    // separator character and used Assembly.LoadFrom directly, but dealing with path canonicalization
+                                    // issues is something we don't want to deal with if we don't have to.
+                                    extensionAssembly = ExtensionLoadFrom(assemblyName);
+                                }
+                                else
+                                {
+                                    throw new WixException(WixErrors.InvalidExtension(assemblyName, innerE.Message));
+                                }
+                            }
+                        }
+                        else
+                        {
+                            throw new WixException(WixErrors.InvalidExtension(assemblyName, e.Message));
+                        }
+                    }
+                }
+
+                if (0 < className.Length)
+                {
+                    try
+                    {
+                        // case 1: AssemblyQualifiedName
+                        extensionType = extensionAssembly.GetType(className, true /* throwOnError */, true /* ignoreCase */);
+                    }
+                    catch (Exception e)
+                    {
+                        throw new WixException(WixErrors.InvalidExtensionType(assemblyName, className, e.GetType().ToString(), e.Message));
+                    }
+                }
+                else
+                {
+                    // if no class name was specified, then let's hope the assembly defined a default WixExtension
+                    AssemblyDefaultHeatExtensionAttribute extensionAttribute = (AssemblyDefaultHeatExtensionAttribute)Attribute.GetCustomAttribute(extensionAssembly, typeof(AssemblyDefaultHeatExtensionAttribute));
+
+                    if (null != extensionAttribute)
+                    {
+                        extensionType = extensionAttribute.ExtensionType;
+                    }
+                    else
+                    {
+                        throw new WixException(WixErrors.InvalidExtensionType(assemblyName, typeof(AssemblyDefaultHeatExtensionAttribute).ToString()));
+                    }
+                }
+            }
+
+            if (extensionType.IsSubclassOf(typeof(HeatExtension)))
+            {
+                return Activator.CreateInstance(extensionType) as HeatExtension;
+            }
+            else
+            {
+                throw new WixException(WixErrors.InvalidExtensionType(extension, extensionType.ToString(), typeof(HeatExtension).ToString()));
+            }
+        }
+
+        /// <summary>
+        /// Parse the command line options for this extension.
+        /// </summary>
+        /// <param name="type">The active harvester type.</param>
+        /// <param name="args">The option arguments.</param>
+        public virtual void ParseOptions(string type, string[] args)
+        {
+        }
+
+        private static Assembly ExtensionLoadFrom(string assemblyName)
+        {
+            Assembly extensionAssembly = null;
+
+            try
+            {
+                extensionAssembly = Assembly.LoadFrom(assemblyName);
+            }
+            catch (Exception e)
+            {
+                throw new WixException(WixErrors.InvalidExtension(assemblyName, e.Message));
+            }
+
+            return extensionAssembly;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Extensibility/IHarvesterCore.cs b/src/WixToolset.Core/Extensibility/IHarvesterCore.cs
new file mode 100644
index 00000000..9a6fd10c
--- /dev/null
+++ b/src/WixToolset.Core/Extensibility/IHarvesterCore.cs
@@ -0,0 +1,62 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset
+{
+    using System;
+    using System.Diagnostics.CodeAnalysis;
+    using System.IO;
+    using WixToolset.Data;
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// The WiX Toolset harvester core.
+    /// </summary>
+    public interface IHarvesterCore
+    {
+        /// <summary>
+        /// Gets whether the harvester core encountered an error while processing.
+        /// </summary>
+        /// <value>Flag if core encountered an error during processing.</value>
+        bool EncounteredError { get; }
+
+        /// <summary>
+        /// Gets or sets the value of the extension argument passed to heat.
+        /// </summary>
+        /// <value>The extension argument.</value>
+        string ExtensionArgument { get; set; }
+
+        /// <summary>
+        /// Gets or sets the value of the root directory that is being harvested.
+        /// </summary>
+        /// <value>The root directory being harvested.</value>
+        string RootDirectory { get; set; }
+
+        /// <summary>
+        /// Create an identifier based on passed file name
+        /// </summary>
+        /// <param name="name">File name to generate identifer from</param>
+        /// <returns></returns>
+        string CreateIdentifierFromFilename(string filename);
+
+        /// <summary>
+        /// Generate an identifier by hashing data from the row.
+        /// </summary>
+        /// <param name="prefix">Three letter or less prefix for generated row identifier.</param>
+        /// <param name="args">Information to hash.</param>
+        /// <returns>The generated identifier.</returns>
+        string GenerateIdentifier(string prefix, params string[] args);
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        void OnMessage(MessageEventArgs mea);
+
+        /// <summary>
+        /// Resolves a file's path if the Wix.File.Source value starts with "SourceDir\".
+        /// </summary>
+        /// <param name="fileSource">The Wix.File.Source value with "SourceDir\".</param>
+        /// <returns>The full path of the file.</returns>
+        string ResolveFilePath(string fileSource);
+    }
+}
diff --git a/src/WixToolset.Core/Extensibility/IHeatCore.cs b/src/WixToolset.Core/Extensibility/IHeatCore.cs
new file mode 100644
index 00000000..bc853b24
--- /dev/null
+++ b/src/WixToolset.Core/Extensibility/IHeatCore.cs
@@ -0,0 +1,36 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Extensibilty
+{
+    using WixToolset.Data;
+
+    /// <summary>
+    /// The WiX Toolset Harvester application core.
+    /// </summary>
+    public interface IHeatCore
+    {
+        /// <summary>
+        /// Gets whether the mutator core encountered an error while processing.
+        /// </summary>
+        /// <value>Flag if core encountered an error during processing.</value>
+        bool EncounteredError { get; }
+
+        /// <summary>
+        /// Gets the harvester.
+        /// </summary>
+        /// <value>The harvester.</value>
+        Harvester Harvester { get; }
+
+        /// <summary>
+        /// Gets the mutator.
+        /// </summary>
+        /// <value>The mutator.</value>
+        Mutator Mutator { get; }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        void OnMessage(MessageEventArgs mea);
+    }
+}
diff --git a/src/WixToolset.Core/Extensibility/MutatorExtension.cs b/src/WixToolset.Core/Extensibility/MutatorExtension.cs
new file mode 100644
index 00000000..9de64180
--- /dev/null
+++ b/src/WixToolset.Core/Extensibility/MutatorExtension.cs
@@ -0,0 +1,198 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Extensibility
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Text;
+
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// The base mutator extension.  Any of these methods can be overridden to change
+    /// the behavior of the mutator.
+    /// </summary>
+    public abstract class MutatorExtension
+    {
+        /// <summary>
+        /// Gets or sets the mutator core for the extension.
+        /// </summary>
+        /// <value>The mutator core for the extension.</value>
+        public IHarvesterCore Core { get; set; }
+
+        /// <summary>
+        /// Gets the sequence of the extension.
+        /// </summary>
+        /// <value>The sequence of the extension.</value>
+        public abstract int Sequence
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Mutate a WiX document.
+        /// </summary>
+        /// <param name="wix">The Wix document element.</param>
+        public virtual void Mutate(Wix.Wix wix)
+        {
+        }
+
+        /// <summary>
+        /// Mutate a WiX document as a string.
+        /// </summary>
+        /// <param name="wix">The Wix document element as a string.</param>
+        /// <returns>The mutated Wix document as a string.</returns>
+        public virtual string Mutate(string wixString)
+        {
+            return wixString;
+        }
+
+        /// <summary>
+        /// Generate unique MSI identifiers.
+        /// </summary>
+        protected class IdentifierGenerator
+        {
+            public const int MaxProductIdentifierLength = 72;
+            public const int MaxModuleIdentifierLength = 35;
+
+            private string baseName;
+            private int maxLength;
+            private Dictionary<string, object> existingIdentifiers;
+            private Dictionary<string, object> possibleIdentifiers;
+
+            /// <summary>
+            /// Instantiate a new IdentifierGenerator.
+            /// </summary>
+            /// <param name="baseName">The base resource name to use if a resource name contains no usable characters.</param>
+            public IdentifierGenerator(string baseName)
+            {
+                this.baseName = baseName;
+                this.maxLength = IdentifierGenerator.MaxProductIdentifierLength;
+                this.existingIdentifiers = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+                this.possibleIdentifiers = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+            }
+
+            /// <summary>
+            /// Gets or sets the maximum length for generated identifiers.
+            /// </summary>
+            /// <value>Maximum length for generated identifiers. (Default is 72.)</value>
+            public int MaxIdentifierLength
+            {
+                get { return this.maxLength; }
+                set { this.maxLength = value; }
+            }
+
+            /// <summary>
+            /// Index an existing identifier for collision detection.
+            /// </summary>
+            /// <param name="identifier">The identifier.</param>
+            public void IndexExistingIdentifier(string identifier)
+            {
+                if (null == identifier)
+                {
+                    throw new ArgumentNullException("identifier");
+                }
+
+                this.existingIdentifiers[identifier] = null;
+            }
+
+            /// <summary>
+            /// Index a resource name for collision detection.
+            /// </summary>
+            /// <param name="name">The resource name.</param>
+            public void IndexName(string name)
+            {
+                if (null == name)
+                {
+                    throw new ArgumentNullException("name");
+                }
+
+                string identifier = this.CreateIdentifier(name, 0);
+
+                if (this.possibleIdentifiers.ContainsKey(identifier))
+                {
+                    this.possibleIdentifiers[identifier] = String.Empty;
+                }
+                else
+                {
+                    this.possibleIdentifiers.Add(identifier, null);
+                }
+            }
+
+            /// <summary>
+            /// Get the identifier for the given resource name.
+            /// </summary>
+            /// <param name="name">The resource name.</param>
+            /// <returns>A legal MSI identifier.</returns>
+            [SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.InvalidOperationException.#ctor(System.String)")]
+            public string GetIdentifier(string name)
+            {
+                if (null == name)
+                {
+                    throw new ArgumentNullException("name");
+                }
+
+                for (int i = 0; i <= Int32.MaxValue; i++)
+                {
+                    string identifier = this.CreateIdentifier(name, i);
+
+                    if (this.existingIdentifiers.ContainsKey(identifier) || // already used
+                        (0 == i && 0 != this.possibleIdentifiers.Count && null != this.possibleIdentifiers[identifier]) || // needs an index because its duplicated
+                        (0 != i && this.possibleIdentifiers.ContainsKey(identifier))) // collides with another possible identifier
+                    {
+                        continue;
+                    }
+                    else // use this identifier
+                    {
+                        this.existingIdentifiers.Add(identifier, null);
+
+                        return identifier;
+                    }
+                }
+
+                throw new InvalidOperationException(WixStrings.EXP_CouldnotFileUniqueIDForResourceName);
+            }
+
+            /// <summary>
+            /// Create a legal MSI identifier from a resource name and an index.
+            /// </summary>
+            /// <param name="name">The name of the resource for which an identifier should be created.</param>
+            /// <param name="index">An index to append to the end of the identifier to make it unique.</param>
+            /// <returns>A legal MSI identifier.</returns>
+            public string CreateIdentifier(string name, int index)
+            {
+                if (null == name)
+                {
+                    throw new ArgumentNullException("name");
+                }
+
+                StringBuilder identifier = new StringBuilder();
+
+                // Convert the name to a standard MSI identifier
+                identifier.Append(Common.GetIdentifierFromName(name));
+
+                // no legal identifier characters were found, use the base id instead
+                if (0 == identifier.Length)
+                {
+                    identifier.Append(this.baseName);
+                }
+
+                // truncate the identifier if it's too long (reserve 3 characters for up to 99 collisions)
+                int adjustedMaxLength = this.MaxIdentifierLength - (index != 0 ? 3 : 0);
+                if (adjustedMaxLength < identifier.Length)
+                {
+                    identifier.Length = adjustedMaxLength;
+                }
+
+                // if the index is not zero, then append it to the identifier name
+                if (0 != index)
+                {
+                    identifier.AppendFormat("_{0}", index);
+                }
+
+                return identifier.ToString();
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Extensibility/ValidatorExtension.cs b/src/WixToolset.Core/Extensibility/ValidatorExtension.cs
new file mode 100644
index 00000000..44ec3106
--- /dev/null
+++ b/src/WixToolset.Core/Extensibility/ValidatorExtension.cs
@@ -0,0 +1,299 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Extensibility
+{
+    using System;
+    using System.Collections;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Base class for creating a validator extension. This default implementation
+    /// will fire and event with the ICE name and description.
+    /// </summary>
+    public class ValidatorExtension : IMessageHandler
+    {
+        private string databaseFile;
+        private Hashtable indexedSourceLineNumbers;
+        private Output output;
+        private SourceLineNumber sourceLineNumbers;
+
+        /// <summary>
+        /// Instantiate a new <see cref="ValidatorExtension"/>.
+        /// </summary>
+        public ValidatorExtension()
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets the path to the database to validate.
+        /// </summary>
+        /// <value>The path to the database to validate.</value>
+        public string DatabaseFile
+        {
+            get { return this.databaseFile; }
+            set { this.databaseFile = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="Output"/> for finding source line information.
+        /// </summary>
+        /// <value>The <see cref="Output"/> for finding source line information.</value>
+        public Output Output
+        {
+            get { return this.output; }
+            set { this.output = value; }
+        }
+
+        /// <summary>
+        /// Called at the beginning of the validation of a database file.
+        /// </summary>
+        /// <remarks>
+        /// <para>The <see cref="Validator"/> will set
+        /// <see cref="DatabaseFile"/> before calling InitializeValidator.</para>
+        /// <para><b>Notes to Inheritors:</b> When overriding
+        /// <b>InitializeValidator</b> in a derived class, be sure to call
+        /// the base class's <b>InitializeValidator</b> to thoroughly
+        /// initialize the extension.</para>
+        /// </remarks>
+        public virtual void InitializeValidator()
+        {
+            if (this.databaseFile != null)
+            {
+                this.sourceLineNumbers = new SourceLineNumber(databaseFile);
+            }
+        }
+
+        /// <summary>
+        /// Called at the end of the validation of a database file.
+        /// </summary>
+        /// <remarks>
+        /// <para>The default implementation will nullify source lines.</para>
+        /// <para><b>Notes to Inheritors:</b> When overriding
+        /// <b>FinalizeValidator</b> in a derived class, be sure to call
+        /// the base class's <b>FinalizeValidator</b> to thoroughly
+        /// finalize the extension.</para>
+        /// </remarks>
+        public virtual void FinalizeValidator()
+        {
+            this.sourceLineNumbers = null;
+        }
+
+        /// <summary>
+        /// Logs a message from the <see cref="Validator"/>.
+        /// </summary>
+        /// <param name="message">A <see cref="String"/> of tab-delmited tokens
+        /// in the validation message.</param>
+        public virtual void Log(string message)
+        {
+            this.Log(message, null);
+        }
+
+        /// <summary>
+        /// Logs a message from the <see cref="Validator"/>.
+        /// </summary>
+        /// <param name="message">A <see cref="String"/> of tab-delmited tokens
+        /// in the validation message.</param>
+        /// <param name="action">The name of the action to which the message
+        /// belongs.</param>
+        /// <exception cref="ArgumentNullException">The message cannot be null.
+        /// </exception>
+        /// <exception cref="WixException">The message does not contain four (4)
+        /// or more tab-delimited tokens.</exception>
+        /// <remarks>
+        /// <para><paramref name="message"/> a tab-delimited set of tokens,
+        /// formatted according to Windows Installer guidelines for ICE
+        /// message. The following table lists what each token by index
+        /// should mean.</para>
+        /// <para><paramref name="action"/> a name that represents the ICE
+        /// action that was executed (e.g. 'ICE08').</para>
+        /// <list type="table">
+        /// <listheader>
+        ///     <term>Index</term>
+        ///     <description>Description</description>
+        /// </listheader>
+        /// <item>
+        ///     <term>0</term>
+        ///     <description>Name of the ICE.</description>
+        /// </item>
+        /// <item>
+        ///     <term>1</term>
+        ///     <description>Message type. See the following list.</description>
+        /// </item>
+        /// <item>
+        ///     <term>2</term>
+        ///     <description>Detailed description.</description>
+        /// </item>
+        /// <item>
+        ///     <term>3</term>
+        ///     <description>Help URL or location.</description>
+        /// </item>
+        /// <item>
+        ///     <term>4</term>
+        ///     <description>Table name.</description>
+        /// </item>
+        /// <item>
+        ///     <term>5</term>
+        ///     <description>Column name.</description>
+        /// </item>
+        /// <item>
+        ///     <term>6</term>
+        ///     <description>This and remaining fields are primary keys
+        ///     to identify a row.</description>
+        /// </item>
+        /// </list>
+        /// <para>The message types are one of the following value.</para>
+        /// <list type="table">
+        /// <listheader>
+        ///     <term>Value</term>
+        ///     <description>Message Type</description>
+        /// </listheader>
+        /// <item>
+        ///     <term>0</term>
+        ///     <description>Failure message reporting the failure of the
+        ///     ICE custom action.</description>
+        /// </item>
+        /// <item>
+        ///     <term>1</term>
+        ///     <description>Error message reporting database authoring that
+        ///     case incorrect behavior.</description>
+        /// </item>
+        /// <item>
+        ///     <term>2</term>
+        ///     <description>Warning message reporting database authoring that
+        ///     causes incorrect behavior in certain cases. Warnings can also
+        ///     report unexpected side-effects of database authoring.
+        ///     </description>
+        /// </item>
+        /// <item>
+        ///     <term>3</term>
+        ///     <description>Informational message.</description>
+        /// </item>
+        /// </list>
+        /// </remarks>
+        public virtual void Log(string message, string action)
+        {
+            if (message == null)
+            {
+                throw new ArgumentNullException("message");
+            }
+
+            string[] messageParts = message.Split('\t');
+            if (3 > messageParts.Length)
+            {
+                if (null == action)
+                {
+                    throw new WixException(WixErrors.UnexpectedExternalUIMessage(message));
+                }
+                else
+                {
+                    throw new WixException(WixErrors.UnexpectedExternalUIMessage(message, action));
+                }
+            }
+
+            SourceLineNumber messageSourceLineNumbers = null;
+            if (6 < messageParts.Length)
+            {
+                string[] primaryKeys = new string[messageParts.Length - 6];
+
+                Array.Copy(messageParts, 6, primaryKeys, 0, primaryKeys.Length);
+
+                messageSourceLineNumbers = this.GetSourceLineNumbers(messageParts[4], primaryKeys);
+            }
+            else // use the file name as the source line information
+            {
+                messageSourceLineNumbers = this.sourceLineNumbers;
+            }
+
+            switch (messageParts[1])
+            {
+                case "0":
+                case "1":
+                    this.OnMessage(WixErrors.ValidationError(messageSourceLineNumbers, messageParts[0], messageParts[2]));
+                    break;
+                case "2":
+                    this.OnMessage(WixWarnings.ValidationWarning(messageSourceLineNumbers, messageParts[0], messageParts[2]));
+                    break;
+                case "3":
+                    this.OnMessage(WixVerboses.ValidationInfo(messageParts[0], messageParts[2]));
+                    break;
+                default:
+                    throw new WixException(WixErrors.InvalidValidatorMessageType(messageParts[1]));
+            }
+        }
+ 
+        /// <summary>
+        /// Gets the source line information (if available) for a row by its table name and primary key.
+        /// </summary>
+        /// <param name="tableName">The table name of the row.</param>
+        /// <param name="primaryKeys">The primary keys of the row.</param>
+        /// <returns>The source line number information if found; null otherwise.</returns>
+        protected SourceLineNumber GetSourceLineNumbers(string tableName, string[] primaryKeys)
+        {
+            // source line information only exists if an output file was supplied
+            if (null != this.output)
+            {
+                // index the source line information if it hasn't been indexed already
+                if (null == this.indexedSourceLineNumbers)
+                {
+                    this.indexedSourceLineNumbers = new Hashtable();
+
+                    // index each real table
+                    foreach (Table table in this.output.Tables)
+                    {
+                        // skip unreal tables
+                        if (table.Definition.Unreal)
+                        {
+                            continue;
+                        }
+
+                        // index each row
+                        foreach (Row row in table.Rows)
+                        {
+                            // skip rows that don't contain source line information
+                            if (null == row.SourceLineNumbers)
+                            {
+                                continue;
+                            }
+
+                            // index the row using its table name and primary key
+                            string primaryKey = row.GetPrimaryKey(';');
+                            if (null != primaryKey)
+                            {
+                                string key = String.Concat(table.Name, ":", primaryKey);
+
+                                if (this.indexedSourceLineNumbers.ContainsKey(key))
+                                {
+                                    this.OnMessage(WixWarnings.DuplicatePrimaryKey(row.SourceLineNumbers, primaryKey, table.Name));
+                                }
+                                else
+                                {
+                                    this.indexedSourceLineNumbers.Add(key, row.SourceLineNumbers);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                return (SourceLineNumber)this.indexedSourceLineNumbers[String.Concat(tableName, ":", String.Join(";", primaryKeys))];
+            }
+
+            // use the file name as the source line information
+            return this.sourceLineNumbers;
+        }
+
+        /// <summary>
+        /// Sends a message to the <see cref="Message"/> delegate if there is one.
+        /// </summary>
+        /// <param name="e">Message event arguments.</param>
+        /// <remarks>
+        /// <para><b>Notes to Inheritors:</b> When overriding <b>OnMessage</b>
+        /// in a derived class, be sure to call the base class's
+        /// <b>OnMessage</b> method so that registered delegates recieve
+        /// the event.</para>
+        /// </remarks>
+        public virtual void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+   }
+}