mvp-xml-cvs — Mailing list for CVS commit messages.

[mvp-xml-cvs] EXSLT/v1/test/ExsltTest/results/EXSLT/Strings align.xml,NONE,1.1 concat.xml,NONE,1.1 decode-uri.xml,NONE,1.1 encode-uri.xml,NONE,1.1 padding.xml,NONE,1.1 replace.xml,NONE,1.1 split.xml,NONE,1.1 tokenize.xml,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltTest/results/EXSLT/Strings
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/test/ExsltTest/results/EXSLT/Strings

Added Files:
	align.xml concat.xml decode-uri.xml encode-uri.xml padding.xml 
	replace.xml split.xml tokenize.xml 
Log Message:


--- NEW FILE: decode-uri.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: split.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: padding.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: encode-uri.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: tokenize.xml ---
<out>
  <test1>
    <token>2001</token>
    <token>06</token>
    <token>03</token>
    <token>11</token>
    <token>40</token>
    <token>23</token>
  </test1>
  <test2>
    <token>date</token>
    <token>math</token>
    <token>str</token>
  </test2>
  <test3>
    <token>f</token>
    <token>o</token>
    <token>o</token>
  </test3>
  <test4>
    <token></token>
  </test4>
</out>
--- NEW FILE: align.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: replace.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: concat.xml ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/test/ExsltTest/results/GotDotNet/RegularExpressions tokenize.xml,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltTest/results/GotDotNet/RegularExpressions
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/test/ExsltTest/results/GotDotNet/RegularExpressions

Added Files:
	tokenize.xml 
Log Message:


--- NEW FILE: tokenize.xml ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/test/ExsltTest/results/GotDotNet/DatesAndTimes avg.xml,NONE,1.1 day-abbreviation.xml,NONE,1.1 day-name.xml,NONE,1.1 max.xml,NONE,1.1 min.xml,NONE,1.1 month-abbreviation.xml,NONE,1.1 month-name.xml,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltTest/results/GotDotNet/DatesAndTimes
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/test/ExsltTest/results/GotDotNet/DatesAndTimes

Added Files:
	avg.xml day-abbreviation.xml day-name.xml max.xml min.xml 
	month-abbreviation.xml month-name.xml 
Log Message:


--- NEW FILE: month-abbreviation.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: avg.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: max.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: min.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: day-name.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: month-name.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: day-abbreviation.xml ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/test/ExsltTest/results/GotDotNet/Dynamic evaluate.xml,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltTest/results/GotDotNet/Dynamic
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/test/ExsltTest/results/GotDotNet/Dynamic

Added Files:
	evaluate.xml 
Log Message:


--- NEW FILE: evaluate.xml ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/test/ExsltTest/results/GotDotNet/Sets subset.xml,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltTest/results/GotDotNet/Sets
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/test/ExsltTest/results/GotDotNet/Sets

Added Files:
	subset.xml 
Log Message:


--- NEW FILE: subset.xml ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/test/ExsltTest/results/EXSLT/RegularExpressions match.xml,NONE,1.1 replace.xml,NONE,1.1 test.xml,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltTest/results/EXSLT/RegularExpressions
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/test/ExsltTest/results/EXSLT/RegularExpressions

Added Files:
	match.xml replace.xml test.xml 
Log Message:


--- NEW FILE: test.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: match.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: replace.xml ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/test/ExsltTest/results/EXSLT/Random random-sequence.xml,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltTest/results/EXSLT/Random
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/test/ExsltTest/results/EXSLT/Random

Added Files:
	random-sequence.xml 
Log Message:


--- NEW FILE: random-sequence.xml ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/test/ExsltTest/results/EXSLT/Math abs.xml,NONE,1.1 acos.xml,NONE,1.1 asin.xml,NONE,1.1 atan.xml,NONE,1.1 atan2.xml,NONE,1.1 constant.xml,NONE,1.1 cos.xml,NONE,1.1 exp.xml,NONE,1.1 highest.xml,NONE,1.1 log.xml,NONE,1.1 lowest.xml,NONE,1.1 max.xml,NONE,1.1 min.xml,NONE,1.1 power.xml,NONE,1.1 random.xml,NONE,1.1 sin.xml,NONE,1.1 sqrt.xml,NONE,1.1 tan.xml,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltTest/results/EXSLT/Math
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/test/ExsltTest/results/EXSLT/Math

Added Files:
	abs.xml acos.xml asin.xml atan.xml atan2.xml constant.xml 
	cos.xml exp.xml highest.xml log.xml lowest.xml max.xml min.xml 
	power.xml random.xml sin.xml sqrt.xml tan.xml 
Log Message:


--- NEW FILE: cos.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: atan2.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: sqrt.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: exp.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: abs.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: acos.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: sin.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: highest.xml ---
<out>
  <test1>                
Max orders: <order>999.99</order><order>999.99</order></test1>
  <test2>                
Max orders: </test2>
  <test3>                
Max orders: </test3>
</out>
--- NEW FILE: min.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: lowest.xml ---
<out>
  <test1>                
lowest orders: <order>1.99</order><order>1.99</order></test1>
  <test2>                
lowest orders: </test2>
  <test3>                
lowest orders: </test3>
</out>
--- NEW FILE: log.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: tan.xml ---
<out>
  <test1>-3.3801404139609579</test1>
  <test2>-1.2833247024302064</test2>
  <test3>NaN</test3>
  <test4>NaN</test4>
  <test5>NaN</test5>
</out>
--- NEW FILE: max.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: constant.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: atan.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: power.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: random.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: asin.xml ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/test/ExsltTest/results/EXSLT/Sets difference.xml,NONE,1.1 distinct.xml,NONE,1.1 has-same-node.xml,NONE,1.1 intersection.xml,NONE,1.1 leading.xml,NONE,1.1 trailing.xml,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltTest/results/EXSLT/Sets
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/test/ExsltTest/results/EXSLT/Sets

Added Files:
	difference.xml distinct.xml has-same-node.xml intersection.xml 
	leading.xml trailing.xml 
Log Message:


--- NEW FILE: distinct.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: difference.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: has-same-node.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: trailing.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: leading.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: intersection.xml ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/src/Exslt/MultiOutput MultiXmlTextWriter.cs,NONE,1.1 OutputState.cs,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/src/Exslt/MultiOutput
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/src/Exslt/MultiOutput

Added Files:
	MultiXmlTextWriter.cs OutputState.cs 
Log Message:


--- NEW FILE: MultiXmlTextWriter.cs ---
#region using

using System;
using System.Xml;
using System.Text;
using System.Collections;    
using System.IO;
using System.Security;

#endregion

namespace Mvp.Xml.Exslt 
{   
    /// <summary>
    /// Specifies the redirecting state of the <c>MultiXmlTextWriter</c>.
    /// </summary>
    internal enum RedirectState {
        /// <summary>
        /// The output is being relayed further (default).
        /// </summary>
        Relaying,
        /// <summary>
        /// The output is being redirected.
        /// </summary>
        Redirecting,
        /// <summary>
        /// <c>&lt;exsl:document></c> attributes are being written
        /// </summary>	        
        WritingRedirectElementAttrs,
        /// <summary>
        /// <c>&lt;exsl:document></c> attribute value is being written
        /// </summary>
        WritingRedirectElementAttrValue
    }
    
	/// <summary>
	/// <para><c>MultiXmlTextWriter</c> class extends standard <c>XmlTextWriter</c> class 
	/// and represents an XML writer that provides a fast, 
	/// non-cached, forward-only way of generating multiple output files containing
	/// either text data or XML data that conforms to the W3C Extensible Markup 
	/// Language (XML) 1.0 and the Namespaces in XML recommendations.</para>	
	/// </summary>
	/// <remarks>
    /// <para>Instances of <c>MultiXmlTextWriter</c> class regognize special element 
    /// (<c>&lt;exsl:document></c> in <c>"http://exslt.org/common"</c> namespace) as
    /// instruction to redirect the output of this element's content to another file. 
	/// When using with <c>XslTransform</c> class, <c>MultiXmlTextWriter</c> class 
	/// allows to generate multiple XSL Transfromation results.</para>	
    /// <para><c>MultiXmlTextWriter</c> class extends <c>System.Xml.XmlTextWriter</c>
    /// class, therefore its instances can be passed directly to the overloaded 
    /// <c>XslTransform.Transform()</c> method, which accepts <c>XmlWriter</c> as 
    /// object to write the transformation result to. All actual XML writing work 
    /// <c>MultiXmlTextWriter</c> class delegates to its base class, but it overrides 
    /// several <c>XmlTextWriter</c> class methods to implement output switching logic 
    /// as follows: once <c>&lt;exsl:document></c> element start tag is detected in 
    /// the XML stream, new writer (<c>XmlTextWriter</c> or <c>StreamWriter</c> depending on
    /// <c>method</c> attribute value) object is created with parameters as specified 
    /// in the attributes of the <c>&lt;exsl:document></c> element and the output 
    /// is switched to this newly created writer untill the end tag of the 
    /// <c>&lt;exsl:document></c> element is encountered.</para>
	/// <para><c>&lt;exsl:document></c> element syntax is as follows:
	/// <code>
    /// &lt;exsl:document
    ///    href = { uri-reference }
    ///    method = { "xml" | "text" }
    ///    encoding = { string }
    ///    omit-xml-declaration = { "yes" | "no" }
    ///    standalone = { "yes" | "no" }
    ///    doctype-public = { string }
    ///    doctype-system = { string }
    ///    indent = { "yes" | "no" }
    ///    &lt;-- Content: template -->
    /// &lt;/exsl:document>
	/// </code></para>
	/// <para>
    /// The <c>href</c> attribute specifies where new result document should be stored, 
    /// it must be an absolute or relative URI. Relative URIs are resolved 
    /// relatively to the parent result document base URI. If the <c>href</c> attribute
    /// specifies that the output should be redirected to a file in a directory
    /// and that directory does not exist, it will be created. This allows to create 
    /// directory trees of any complexity.</para>
    /// <para>Semantics of the rest attributes is as defined in W3C XSLT 1.0 Recommendation 
    /// for <c>&lt;xsl:output></c> element, see 
    /// <a href="http://www.w3.org/TR/xslt.html#output">http://www.w3.org/TR/xslt.html#output</a>.
	/// </para>
	/// <para><b>Note:</b> <c>&lt;exsl:document></c> element namespace prefix must be bound to 
	/// <c>"http://exslt.org/common"</c> namespace URI in order to be recognized by 
	/// <c>MultiXmlTextWriter</c> class as a redirecting instruction. </para>
	/// </remarks>
	/// <example>This example shows how to use <c>MultiXmlTextWriter</c> along with 
	/// <c>XslTransform</c> to achieve create multiple result documents in one
	/// transfromation run:
	/// <para>In XSL stylesheet document declare <c>"http://exslt.org/common"</c> namespace
	/// and whenever you want to create new result document make use of <c>&lt;exsl:documnet></c>
	/// element:<br/>
	/// <c>style.xsl</c> stylesheet fragment:
	/// <code>
	/// <![CDATA[
    /// <xsl:stylesheet version="1.0" 
    ///   xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    ///   ]]><b>xmlns:exsl= "http://exslt.org/common"</b><![CDATA[ 
    ///   ]]><b>exclude-result-prefixes="exsl"</b>><![CDATA[ 
    ///   <xsl:template match="book">
    ///     <!-- Builds frameset -->
    ///     <html> 
    ///       <head>
    ///         <title><xsl:value-of select="@title"/></title> 
    ///       </head>
    ///       <frameset cols="20%,80%"> 
    ///         <frame src="toc.html"/> 
    ///         <!-- Builds table of contents output document -->    
    ///         ]]><b>&lt;exsl:document href="toc.html" indent="yes"></b><![CDATA[
    ///           <html>
    ///             <head>
    ///               <title>Table of Contents</title>
    ///             </head>
    ///             <body>
    ///               <ul>
    ///                 <xsl:apply-templates mode="toc"/> 
    ///               </ul> 
    ///             </body>                      
    ///           </html>
    ///         ]]><b>&lt;/exsl:document></b><![CDATA[ 
    ///         <frame src="{chapter[1]/@id}.html" name="body" />
    ///         <xsl:apply-templates />
    ///       </frameset> 
    ///     </html>
    ///     ...  
	///
	/// ]]>
	/// </code>
	/// C# code fragment:	
    /// <code>
    /// XPathDocument doc = new XPathDocument("book.xml");
    /// XslTransform xslt = new XslTransform();
    /// xslt.Load("style.xsl");	            
    /// MultiXmlTextWriter multiWriter = 
    ///     new MultiXmlTextWriter("index.html", Encoding.UTF8);
    /// multiWriter.Formatting = Formatting.Indented;
    /// xslt.Transform(doc, null, multiWriter);
    /// </code>
    /// </para>
	/// </example>
	public class MultiXmlTextWriter : XmlTextWriter {
	    /// <summary>
	    /// This constant is the namespace <c>&lt;exsl:document></c> element 
	    /// should belong to in order to be recognized as redirect instruction.
	    /// It's <c>"http://exslt.org/common"</c> as defined by 
	    /// <a href="http://www.exslt.org">EXSLT community initiative</a>.
	    /// </summary>	    	     
	    protected const string RedirectNamespace = "http://exslt.org/common";	    
	    /// <summary>
	    /// This constant is the redirect instruction element name.
        /// It's <c>"document"</c> as defined by 
        /// <a href="http://www.exslt.org">EXSLT community initiative</a>.
	    /// </summary>
	    protected const string RedirectElementName = "document";	    
	    	    
	    // Stack of output states
	    Stack states = null;	    
	    // Current output state
	    OutputState state = null;		        	    
	    // Currently processed attribute name 
	    string currentAttributeName;	   
	    	    	    	    
	    //Redirecting state - relaying by default
	    RedirectState redirectState = RedirectState.Relaying;
	    	    	    	    	                   
        /// <summary>
        /// Creates an instance of the <c>MultiXmlTextWriter</c> class using the specified filename and
        /// encoding.
        /// Inherited from <c>XmlTextWriter</c>, see <see cref="XmlTextWriter"/>.
        /// Overridden to set output directory.
        /// </summary>
        /// <param name="fileName">The filename to write to. If the file exists, it will truncate it and overwrite it 
        /// with the new content.</param>
        /// <param name="encoding">The encoding to generate. If encoding is a null reference it writes the file out 
        /// as UTF-8, and omits the encoding attribute from the ProcessingInstruction.</param>
        /// <exception cref="ArgumentException">The encoding is not supported; the filename is empty, contains only 
        /// white space, or contains one or more invalid characters.</exception>
        /// <exception cref="UnauthorizedAccessException">Access is denied.</exception>
        /// <exception cref="ArgumentNullException">The filename is a null reference.</exception>
        /// <exception cref="DirectoryNotFoundException">The directory to write to is not found.</exception>
        /// <exception cref="IOException">The filename includes an incorrect or invalid syntax 
        /// for file name, directory name, or volume label syntax.</exception>
        /// <exception cref="SecurityException">The caller does not have the required permission.</exception>
        public MultiXmlTextWriter(String fileName, Encoding encoding):base(fileName, encoding) {
            DirectoryInfo dir = Directory.GetParent(fileName);                       
            Directory.SetCurrentDirectory(dir.ToString());
        }
        
        /// <summary>
        /// Creates an instance of the <c>MultiXmlTextWriter</c> class using the specified 
        /// <c>TextWriter</c>, see <see cref="TextWriter"/>.
        /// Inherited from <c>XmlTextWriter</c>, see <see cref="XmlTextWriter"/>.
        /// </summary>
        /// <param name="w">The <c>TextWriter</c> to write to. It is assumed that the <c>TextWriter</c> is 
        /// already set to the correct encoding.</param>
        public MultiXmlTextWriter(TextWriter w):base(w) {}
        
        /// <summary>
        /// Creates an instance of the <c>MultiXmlTextWriter</c> class using the specified 
        /// stream and encoding.
        /// Inherited from <c>XmlTextWriter</c>, see <see cref="XmlTextWriter"/>.
        /// </summary>
        /// <param name="w">The stream to which you want to write.</param>
        /// <param name="encoding">The encoding to generate. If encoding is a null 
        /// reference it writes out the stream as UTF-8 and omits the encoding attribute 
        /// from the ProcessingInstruction.</param>
        /// <exception cref="ArgumentException">The encoding is not supported or the stream 
        /// cannot be written to.</exception>
        /// <exception cref="ArgumentNullException">w is a null reference.</exception>
        public MultiXmlTextWriter(Stream w, Encoding encoding):base(w, encoding) {}
                        
        /// <summary>
        /// Checks possible start of <c>&lt;exsl:document></c> element content.         
        /// </summary>
        /// <remarks>
        /// When <c>&lt;exsl:document></c> element start tag is detected, the beginning of the 
        /// element's content might be detected as any next character data (not attribute
        /// value though), element start tag, processing instruction or comment.
        /// </remarks>
        /// <exception cref="ArgumentNullException">Thrown when <c>href</c> attribute is absent.</exception>
        /// <exception cref="ArgumentException">Thrown when a document, specified by <c>href</c> attribute is
        /// opened alreary. Two nested <c>&lt;exsl:document></c></exception> elements cannot specify the same 
        /// output URI in their <c>href</c> attributes.
        private void CheckContentStart() {
            if (redirectState == RedirectState.WritingRedirectElementAttrs) {
                //Check required href attribute
                if (state.Href == null)
                    throw new ArgumentNullException("'href' attribute of exsl:document element must be specified.");            
                //Are we writing to this URI already?
                foreach (OutputState nestedState in states)
                    if (nestedState.Href == state.Href)
                        throw new ArgumentException("Cannot write to " + state.Href + " two documents simultaneously.");                
                state.InitWriter();                                
                redirectState = RedirectState.Redirecting;
            }    
        } 
        /// <summary>
        /// Writes the specified start tag and associates it with the given namespace and prefix.
        /// Inherited from <c>XmlTextWriter</c>, see <see cref="XmlTextWriter.WriteStartElement"/>
        /// Overridden to detect <c>exsl:document</c> element start tag.
        /// </summary>        
        /// <param name="prefix">The namespace prefix of the element.</param>
        /// <param name="localName">The local name of the element.</param>
        /// <param name="ns">The namespace URI to associate with the element. If this namespace 
        /// is already in scope and has an associated prefix then the writer will automatically write that prefix also. </param>
        /// <exception cref="InvalidOperationException">The writer is closed.</exception>
        public override void WriteStartElement(string prefix, string localName, string ns) {        
            CheckContentStart();                            
            //Is it exsl:document redirecting instruction?
            if (ns == RedirectNamespace && localName == RedirectElementName) {                
                //Lazy stack of states
                if (states == null)
                    states = new Stack();
                //If we are redirecting already - push the current state into the stack
                if (redirectState == RedirectState.Redirecting)
                    states.Push(state);
                //Initialize new state
                state = new OutputState();
                redirectState = RedirectState.WritingRedirectElementAttrs;
            } else {                            
                if (redirectState == RedirectState.Redirecting) {
                    if (state.Method == OutputMethod.Text) {
                        state.Depth++;
                        return;
                    }   
                    //Write doctype before the first element
                    if (state.Depth == 0 && state.SystemDoctype != null)
                        if (prefix != String.Empty)
                            state.XmlWriter.WriteDocType(prefix+":"+localName, 
                                state.PublicDoctype,state.SystemDoctype, null);
                        else
                            state.XmlWriter.WriteDocType(localName, 
                                state.PublicDoctype,state.SystemDoctype, null);   
                    state.XmlWriter.WriteStartElement(prefix, localName, ns);                
                    state.Depth++;
                } else
                    base.WriteStartElement(prefix, localName, ns);              
            }
        }
        
        /// <summary>
        /// Finishes output redirecting - closes current writer 
        /// and pops previous state.
        /// </summary>
        internal void FinishRedirecting() {            
            state.CloseWriter();
            //Pop previous state if it exists
            if (states.Count != 0) {
                state = (OutputState)states.Pop();
                redirectState = RedirectState.Redirecting;
            } else {
                state = null;
                redirectState = RedirectState.Relaying;
            }
        }
        
        /// <summary>
        /// Closes one element and pops the corresponding namespace scope.
        /// Inherited from <c>XmlTextWriter</c>, see <see cref="XmlTextWriter.WriteEndElement"/>
        /// Overridden to detect <c>exsl:document</c> element end tag.
        /// </summary>                
        public override void WriteEndElement() {
            CheckContentStart();
            if (redirectState == RedirectState.Redirecting) {                
                //Check if that's exsl:document end tag
                if (state.Depth-- == 0)
                    FinishRedirecting();    
                else {
                    if (state.Method == OutputMethod.Text)
                        return;
                    state.XmlWriter.WriteEndElement();                         
                }
            } 
            else 
                base.WriteEndElement();
        }
        
        /// <summary>
        /// Closes one element and pops the corresponding namespace scope.
        /// Inherited from <c>XmlTextWriter</c>, see <see cref="XmlTextWriter.WriteFullEndElement"/>
        /// Overridden to detect <c>exsl:document</c> element end tag.
        /// </summary>                
        public override void WriteFullEndElement() {
            CheckContentStart();
            if (redirectState == RedirectState.Redirecting) {                
                //Check if it's exsl:document end tag
                if (state.Depth-- == 0)                                        
                    FinishRedirecting();               
                else {
                    if (state.Method == OutputMethod.Text)
                        return;
                    state.XmlWriter.WriteFullEndElement();                         
                }
            } else 
                base.WriteFullEndElement();                
        }
                
        /// <summary>
        /// Writes the start of an attribute.
        /// Inherited from <c>XmlTextWriter</c>, see <see cref="XmlTextWriter.WriteStartAttribute"/>
        /// Overridden to detect <c>exsl:document</c> attribute names and to redirect
        /// the output.
        /// </summary>
        /// <param name="prefix">Namespace prefix of the attribute.</param>
        /// <param name="localName">Local name of the attribute.</param>
        /// <param name="ns">Namespace URI of the attribute.</param>                                            
        /// <exception cref="ArgumentException"><c>localName</c>c> is either a null reference or <c>String.Empty</c>.</exception>
        public override void WriteStartAttribute(string prefix, string localName, string ns) {
            if (redirectState == RedirectState.WritingRedirectElementAttrs) {                                
                redirectState = RedirectState.WritingRedirectElementAttrValue;
                currentAttributeName = localName;                
            } else if (redirectState == RedirectState.Redirecting) {
                if (state.Method == OutputMethod.Text)
                    return;
                state.XmlWriter.WriteStartAttribute(prefix, localName, ns);                
            } else
                base.WriteStartAttribute(prefix, localName, ns);
        }
                
        /// <summary>
        /// Closes the previous <c>WriteStartAttribute</c> call.
        /// Inherited from <c>XmlTextWriter</c>, see <see cref="XmlTextWriter.WriteEndAttribute"/>
        /// Overridden to redirect the output.
        /// </summary>        
        public override void WriteEndAttribute() {                         
            if (redirectState == RedirectState.WritingRedirectElementAttrValue)
                redirectState = RedirectState.WritingRedirectElementAttrs;
            else if (redirectState == RedirectState.Redirecting) {
                if (state.Method == OutputMethod.Text)
                    return;
                state.XmlWriter.WriteEndAttribute();
            } else
                base.WriteEndAttribute();
        }
        
        /// <summary>
        /// Writes out a comment &lt;!--...--> containing the specified text.
        /// Inherited from <c>XmlTextWriter</c>, see <see cref="XmlTextWriter.WriteComment"/>
        /// Overriden to redirect the output.
        /// </summary>
        /// <param name="text">Text to place inside the comment.</param>        
        /// <exception cref="ArgumentException">The text would result in a non-well formed XML document.</exception>
        /// <exception cref="InvalidOperationException">The <c>WriteState</c> is Closed.</exception>
        public override void WriteComment(string text) {            
            CheckContentStart();
            if (redirectState == RedirectState.Redirecting) {
                if (state.Method == OutputMethod.Text)
                    return;
                state.XmlWriter.WriteComment(text);
            } else
                base.WriteComment(text);
        }
        
        /// <summary>
        /// Writes out a processing instruction with a space between the name 
        /// and text as follows: &lt;?name text?>.
        /// Inherited from <c>XmlTextWriter</c>, see <see cref="XmlTextWriter.WriteProcessingInstruction"/>
        /// Overridden to redirect the output.
        /// </summary>
        /// <param name="name">Name of the processing instruction.</param>
        /// <param name="text">Text to include in the processing instruction.</param>        
        /// <exception cref="ArgumentException"><para>The text would result in a non-well formed XML document.</para> 
        /// <para><c>name</c> is either a null reference or <c>String.Empty</c>.</para>
        /// <para>This method is being used to create an XML declaration after 
        /// <c>WriteStartDocument</c> has already been called.</para></exception>
        public override void WriteProcessingInstruction(string name, string text) {
            CheckContentStart();
            if (redirectState == RedirectState.Redirecting) {
                if (state.Method == OutputMethod.Text)
                    return;
                state.XmlWriter.WriteProcessingInstruction(name, text);
            } else
                base.WriteProcessingInstruction(name, text);
        }
        
        /// <summary>
        /// Writes the given text content.
        /// Inherited from <c>XmlTextWriter</c>, see <see cref="XmlTextWriter.WriteString"/>
        /// Overridden to detect <c>exsl:document</c> element attribute values and to 
        /// redirect the output.
        /// </summary>
        /// <param name="text">Text to write.</param>        
        /// <exception cref="ArgumentException">The text string contains an invalid surrogate pair.</exception>
        public override void WriteString(string text) {
            //Possible exsl:document's attribute value
            if (redirectState == RedirectState.WritingRedirectElementAttrValue) {
                switch (currentAttributeName) {
                    case "href":
                        state.Href = text;
                        break;
                    case "method":
                        if (text == "text")
                            state.Method = OutputMethod.Text;
                        break;    
                    case "encoding":
                        try {
                            state.Encoding = Encoding.GetEncoding(text);
                        } catch (Exception) {}    
                        break;
                    case "indent":
                        if (text == "yes")
                            state.Indent = true;
                        break;
                    case "doctype-public":
                        state.PublicDoctype = text;
                        break;
                    case "doctype-system":
                        state.SystemDoctype = text;
                        break;    
                    case "standalone":
                        if (text == "yes")
                            state.Standalone = true;
                        break;
                    case "omit-xml-declaration":
                        if (text == "yes")
                            state.OmitXmlDeclaration = true;
                        break;
                    default:
                        break;    
                }                
                return;
            } else
                CheckContentStart();
            if (redirectState == RedirectState.Redirecting) {
                if (state.Method == OutputMethod.Text)
                    state.TextWriter.Write(text);
                else
                    state.XmlWriter.WriteString(text);
            } else
                base.WriteString(text);
        }
    }                       
}

--- NEW FILE: OutputState.cs ---
#region using

using System;
using System.Xml;
using System.Text;
using System.IO;

#endregion

namespace Mvp.Xml.Exslt 
{   

    /// <summary>
    /// XSLT output method enumeration, see W3C XSLT 1.0 Recommendation at 
    /// <a href="http://www.w3.org/TR/xslt.html#output">http://www.w3.org/TR/xslt.html#output</a>.    
    /// </summary>
    /// <remarks>Only <c>xml</c> and <c>text</c> methods are supported by this version of 
    /// the <c>MultiXmlTextWriter</c>.</remarks>
    internal enum OutputMethod { Xml, Text };
    
    /// <summary>
    /// This class represents redirected output state and properties.
    /// </summary>    
    internal class OutputState {            
        private XmlTextWriter xmlWriter;                        
        private StreamWriter textWriter;
        private int depth;
        private string href;                           
        private Encoding encoding;        
        private bool indent;        
        private string publicDoctype;        
        private string systemDoctype;        
        private bool standalone;        
        private string storedDir;
        private OutputMethod method;
        private bool omitXmlDecl;
                                                                                                     
        /// <summary>
        /// Creates new <c>OutputState</c> with default properties values:
        /// UTF8 encoding, no indentation, nonstandalone document, XML output
        /// method.
        /// </summary>                                    
        public OutputState() {
            encoding = System.Text.Encoding.UTF8;
            indent = false;
            standalone = false;
            omitXmlDecl = false;
            method = OutputMethod.Xml;
        }                                   
         
        /// <summary>
        /// Initializes the writer to write redirected output. 
        /// </summary>              
        /// <remarks>Depending on the <c>method</c> attribute value, 
        /// <c>XmlTextWriter</c> or <c>StreamWriter</c> is created. 
        /// <c>XmlTextWriter</c> is used for outputting XML and  
        /// <c>StreamWriter</c> - for plain text.
        /// </remarks>
        public void InitWriter() {
            // Save current directory
            storedDir = Directory.GetCurrentDirectory();
            DirectoryInfo dir = Directory.GetParent(href);
            if (!dir.Exists)
                dir.Create();
            // Create writer
            if (method == OutputMethod.Xml) {
                xmlWriter = new XmlTextWriter(href, encoding);
                if (indent)
                    xmlWriter.Formatting = Formatting.Indented;
                if (!omitXmlDecl) 
                {
                    if (standalone)    
                        xmlWriter.WriteStartDocument(true);
                    else
                        xmlWriter.WriteStartDocument();
                }
            } else
                textWriter = new StreamWriter(href, false, encoding);
            // Set new current directory            
            Directory.SetCurrentDirectory(dir.ToString());                                    
        }      
        
        /// <summary>
        /// Closes the writer that was used to write redirected output.
        /// </summary>
        public void CloseWriter() {
            if (method == OutputMethod.Xml) {
                if (!omitXmlDecl) 
                {
                    xmlWriter.WriteEndDocument();
                }
                xmlWriter.Close();    
            } else
                textWriter.Close();
            // Restore previous current directory
            Directory.SetCurrentDirectory(storedDir);
        }
                                                   
        /// <summary>
        /// Specifies whether the result document should be written with 
        /// a standalone XML document declaration.
        /// </summary>
        /// <value>Standalone XML declaration as per W3C XSLT 1.0 Recommendation (see 
        /// <a href="http://www.w3.org/TR/xslt.html#output">http://www.w3.org/TR/xslt.html#output</a>
        /// for more info).</value>
        /// <remarks>The property does not affect output while output method is <c>text</c>.</remarks>            
        public bool Standalone {
            get { return standalone; }
            set { standalone = value; }
        }        
        
        /// <summary>
        /// Specifies output method.
        /// </summary>
        /// <value>Output Method as per W3C XSLT 1.0 Recommendation (see 
        /// <a href="http://www.w3.org/TR/xslt.html#output">http://www.w3.org/TR/xslt.html#output</a>
        /// for more info).</value>        
        public OutputMethod Method {
            get { return method; }
            set { method = value; }
        }
        
        /// <summary>
        /// Specifies the URI where the result document should be written to.
        /// </summary>                            
        /// <value>Absolute or relative URI of the output document.</value>
        public string Href {
            get { return href; }
            set { href = value; }
        }
        
        /// <summary>
        /// Specifies the preferred character encoding of the result document.
        /// </summary>
        /// <value>Output encoding as per W3C XSLT 1.0 Recommendation (see 
        /// <a href="http://www.w3.org/TR/xslt.html#output">http://www.w3.org/TR/xslt.html#output</a>
        /// for more info).</value>
        public Encoding Encoding {
            get { return encoding; }
            set { encoding = value; }
        }
        
        /// <summary>
        /// Specifies whether the result document should be written in the 
        /// indented form.
        /// </summary>
        /// <value>Output document formatting as per W3C XSLT 1.0 Recommendation (see 
        /// <a href="http://www.w3.org/TR/xslt.html#output">http://www.w3.org/TR/xslt.html#output</a>
        /// for more info).</value>
        /// <remarks>The property does not affect output while output method is <c>text</c>.</remarks>
        public bool Indent {
            get { return indent; }
            set { indent = value; }
        }
        
        /// <summary>
        /// Specifies the public identifier to be used in the document 
        /// type declaration.
        /// </summary>
        /// <value>Public part of the output document type definition as per W3C XSLT 1.0 Recommendation (see 
        /// <a href="http://www.w3.org/TR/xslt.html#output">http://www.w3.org/TR/xslt.html#output</a>
        /// for more info).</value>
        /// <remarks>The property does not affect output while output method is <c>text</c>.</remarks>
        public string PublicDoctype {
            get { return publicDoctype; }
            set { publicDoctype = value; }
        }
        
        /// <summary>
        /// Specifies the system identifier to be used in the document 
        /// type declaration.
        /// </summary>
        /// <value>System part of the output document type definition as per W3C XSLT 1.0 Recommendation (see 
        /// <a href="http://www.w3.org/TR/xslt.html#output">http://www.w3.org/TR/xslt.html#output</a>
        /// for more info).</value>
        /// <remarks>The property does not affect output while output method is <c>text</c>.</remarks>
        public string SystemDoctype {
            get { return systemDoctype; }
            set { systemDoctype = value; }
        }                                    
                                    
        /// <summary>
        /// Actual <c>XmlTextWriter</c> used to write the redirected 
        /// result document.
        /// </summary>              
        /// <value><c>XmlWriter</c>, which is used to write the output document in XML method.</value>                      
        public XmlTextWriter XmlWriter {
            get { return xmlWriter; }                                
        }
        
        /// <summary>
        /// Actual <c>TextWriter</c> used to write the redirected 
        /// result document in text output method.
        /// </summary>                                    
        /// <value><c>StreamWriter</c>, which is used to write the output document in text method.</value>
        public StreamWriter TextWriter {
            get { return textWriter; }                                
        }    
            
        /// <summary>
        /// Tree depth (used to detect end tag of the <c>exsl:document</c>).
        /// </summary>
        /// <value>Current output tree depth.</value>
        public int Depth {
            get { return depth; }
            set { depth = value; }
        }
        
        /// <summary>
        /// Specifies whether the XSLT processor should output an XML declaration.        
        /// </summary>        
        public bool OmitXmlDeclaration
        {
            get { return omitXmlDecl; }
            set { omitXmlDecl = value; }
        }                                 
    }
}

[mvp-xml-cvs] EXSLT/v1/test/ExsltTest .cvsignore,NONE,1.1 AssemblyInfo.cs,NONE,1.1 AvailabilityTest.cmd,NONE,1.1 ExsltCommonTests.cs,NONE,1.1 ExsltDatesAndTimesTests.cs,NONE,1.1 ExsltMathTests.cs,NONE,1.1 ExsltRandomTests.cs,NONE,1.1 ExsltRegularExpressionsTests.cs,NONE,1.1 ExsltSetsTests.cs,NONE,1.1 ExsltStringsTests.cs,NONE,1.1 ExsltTest.cs,NONE,1.1 ExsltTest.csproj,NONE,1.1 ExsltTest.csproj.user,NONE,1.1 ExsltTest.csproj.vspscc,NONE,1.1 ExsltTest.dll,NONE,1.1 ExsltTest.exe,NONE,1.1 ExsltUnitTests.cs,NONE,1.1 FunctionsAvailability.html,NONE,1.1 GDNDatesAndTimesTests.cs,NONE,1.1 GDNDynamicTests.cs,NONE,1.1 GDNMathTests.cs,NONE,1.1 GDNRegularExpressionsTests.cs,NONE,1.1 GDNSetsTests.cs,NONE,1.1 GDNStringsTests.cs,NONE,1.1 Makefile,NONE,1.1 Mvp.Xml.Exslt.dll,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltTest
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/test/ExsltTest

Added Files:
	.cvsignore AssemblyInfo.cs AvailabilityTest.cmd 
	ExsltCommonTests.cs ExsltDatesAndTimesTests.cs 
	ExsltMathTests.cs ExsltRandomTests.cs 
	ExsltRegularExpressionsTests.cs ExsltSetsTests.cs 
	ExsltStringsTests.cs ExsltTest.cs ExsltTest.csproj 
	ExsltTest.csproj.user ExsltTest.csproj.vspscc ExsltTest.dll 
	ExsltTest.exe ExsltUnitTests.cs FunctionsAvailability.html 
	GDNDatesAndTimesTests.cs GDNDynamicTests.cs GDNMathTests.cs 
	GDNRegularExpressionsTests.cs GDNSetsTests.cs 
	GDNStringsTests.cs Makefile Mvp.Xml.Exslt.dll 
Log Message:


--- NEW FILE: .cvsignore ---
bin
obj
*.user
*.suo
*.dll
*.pdb
*.exe
--- NEW FILE: ExsltRegularExpressionsTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for EXSLT RegularExpressions module functions.
    /// </summary>
    [TestFixture]
    public class ExsltRegularExpressionsTests : ExsltUnitTests
    {        

        protected override string TestDir 
        {
            get { return "tests/EXSLT/RegularExpressions/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/EXSLT/RegularExpressions/"; }
        }   
                       
        /// <summary>
        /// Tests the following function:
        ///     regexp:test()
        /// </summary>
        [Test]
        public void TestTest() 
        {
            RunAndCompare("source.xml", "test.xslt", "test.xml");
        }   
         
        /// <summary>
        /// Tests the following function:
        ///     regexp:match()
        /// </summary>
        [Test]
        public void MatchTest() 
        {
            RunAndCompare("source.xml", "match.xslt", "match.xml");
        }   

        /// <summary>
        /// Tests the following function:
        ///     regexp:replace()
        /// </summary>
        [Test]
        public void ReplaceTest() 
        {
            RunAndCompare("source.xml", "replace.xslt", "replace.xml");
        }   
    }
}

--- NEW FILE: ExsltTest.csproj.vspscc ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: ExsltTest.exe ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: GDNDynamicTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for GotDotNet Dynamic module functions.
    /// </summary>
    [TestFixture]
    public class GDNDynamicTests : ExsltUnitTests
    {        
        protected override string TestDir 
        {
            get { return "tests/GotDotNet/Dynamic/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/GotDotNet/Dynamic/"; }
        } 
        
        /// <summary>
        /// Tests the following function:
        ///     dyn2:evaluate()
        /// </summary>
        [Test]
        public void EvaluateTest() 
        {
            RunAndCompare("source.xml", "evaluate.xslt", "evaluate.xml");
        }        
    }
}

--- NEW FILE: Makefile ---
all:            
	@echo off
        @echo ########### Builds Exslt library...
        cd ..\Exslt
        nmake
        @echo ########### Builds ExsltTest utility...
        cd ..\ExsltTest	
        csc /r:..\Exslt\GotDotNet.Exslt.dll /out:ExsltTest.exe /target:exe ExsltTest.cs /debug- /optimize+
	copy ..\Exslt\GotDotNet.Exslt.dll GotDotNet.Exslt.dll
        
--- NEW FILE: GDNStringsTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for GotDotNet Strings module functions.
    /// </summary>
    [TestFixture]
    public class GDNStringsTests : ExsltUnitTests
    {        
        protected override string TestDir 
        {
            get { return "tests/GotDotNet/Strings/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/GotDotNet/Strings/"; }
        }                

        /// <summary>
        /// Tests the following function:
        ///     str2:lowercase()
        /// </summary>
        [Test]
        public void LowercaseTest() 
        {
            RunAndCompare("source.xml", "lowercase.xslt", "lowercase.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str2:uppercase()
        /// </summary>
        [Test]
        public void UppercaseTest() 
        {
            RunAndCompare("source.xml", "uppercase.xslt", "uppercase.xml");
        }
    }
}

--- NEW FILE: AssemblyInfo.cs ---
using System.Reflection;
using System.Runtime.CompilerServices;

//
// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly: AssemblyTitle("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]		

//
// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version 
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Revision and Build Numbers 
// by using the '*' as shown below:

[assembly: AssemblyVersion("1.0.*")]

//
// In order to sign your assembly you must specify a key to use. Refer to the 
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing. 
//
// Notes: 
//   (*) If no key is specified, the assembly is not signed.
//   (*) KeyName refers to a key that has been installed in the Crypto Service
//       Provider (CSP) on your machine. KeyFile refers to a file which contains
//       a key.
//   (*) If the KeyFile and the KeyName values are both specified, the 
//       following processing occurs:
//       (1) If the KeyName can be found in the CSP, that key is used.
//       (2) If the KeyName does not exist and the KeyFile does exist, the key 
//           in the KeyFile is installed into the CSP and used.
//   (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
//       When specifying the KeyFile, the location of the KeyFile should be
//       relative to the project output directory which is
//       %Project Directory%\obj\<configuration>. For example, if your KeyFile is
//       located in the project directory, you would specify the AssemblyKeyFile 
//       attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
//   (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
//       documentation for more information on this.
//
[assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyFile("")]
[assembly: AssemblyKeyName("")]

--- NEW FILE: ExsltStringsTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
	/// <summary>
	/// Collection of unit tests for EXSLT Strings module functions.
	/// </summary>
	[TestFixture]
	public class ExsltStringsTests : ExsltUnitTests
	{        
        protected override string TestDir 
        {
            get { return "tests/EXSLT/Strings/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/EXSLT/Strings/"; }
        }                

        /// <summary>
        /// Tests the following function:
        ///     str:tokenize()
        /// </summary>
        [Test]
        public void TokenizeTest() 
        {
            RunAndCompare("source.xml", "tokenize.xslt", "tokenize.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str:replace()
        /// </summary>
        [Test]
        public void ReplaceTest() 
        {
            RunAndCompare("source.xml", "replace.xslt", "replace.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str:padding()
        /// </summary>
        [Test]
        public void PaddingTest() 
        {
            RunAndCompare("source.xml", "padding.xslt", "padding.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str:align()
        /// </summary>
        [Test]
        public void AlignTest() 
        {
            RunAndCompare("source.xml", "align.xslt", "align.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str:encode-uri()
        /// </summary>
        [Test]
        public void EncodeUriTest() 
        {
            RunAndCompare("source.xml", "encode-uri.xslt", "encode-uri.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str:decode-uri()
        /// </summary>
        [Test]
        public void DecodeUriTest() 
        {
            RunAndCompare("source.xml", "decode-uri.xslt", "decode-uri.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str:concat()
        /// </summary>
        [Test]
        public void ConcatTest() 
        {
            RunAndCompare("source.xml", "concat.xslt", "concat.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str:split()
        /// </summary>
        [Test]
        public void SplitTest() 
        {
            RunAndCompare("source.xml", "split.xslt", "split.xml");
        }
	}
}

--- NEW FILE: GDNRegularExpressionsTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for GotDotNet RegularExpressions module functions.
    /// </summary>
    [TestFixture]
    public class GDNRegularExpressionsTests : ExsltUnitTests
    {        

        protected override string TestDir 
        {
            get { return "tests/GotDotNet/RegularExpressions/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/GotDotNet/RegularExpressions/"; }
        }   
                       
        /// <summary>
        /// Tests the following function:
        ///     regexp2:tokenize()
        /// </summary>
        [Test]
        public void TokenizeTest() 
        {
            RunAndCompare("source.xml", "tokenize.xslt", "tokenize.xml");
        }                    
    }
}

--- NEW FILE: ExsltRandomTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for EXSLT Random module functions.
    /// </summary>
    [TestFixture]
    public class ExsltRandomTests : ExsltUnitTests
    {        

        protected override string TestDir 
        {
            get { return "tests/EXSLT/Random/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/EXSLT/Random/"; }
        }   
                       
        /// <summary>
        /// Tests the following function:
        ///     random:random-sequence()
        /// </summary>
        [Test]
        public void RandomSequenceTest() 
        {
            RunAndCompare("source.xml", "random-sequence.xslt", "random-sequence.xml");
        }          
    }
}

--- NEW FILE: GDNSetsTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for GotDotNet Sets module functions.
    /// </summary>
    [TestFixture]
    public class GDNSetsTests : ExsltUnitTests
    {        

        protected override string TestDir 
        {
            get { return "tests/GotDotNet/Sets/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/GotDotNet/Sets/"; }
        }   
                       
        /// <summary>
        /// Tests the following function:
        ///     set2:subset()
        /// </summary>
        [Test]
        public void SubsetTest() 
        {
            RunAndCompare("source.xml", "subset.xslt", "subset.xml");
        }                
    }
}

--- NEW FILE: ExsltTest.dll ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: FunctionsAvailability.html ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: ExsltTest.csproj.user ---
<VisualStudioProject>
    <CSHARP LastOpenVersion = "7.10.3077" >
        <Build>
            <Settings ReferencePath = "D:\projects\EXSLT.NET\Exslt\;D:\projects\Mvp.Xml\EXSLT\v1\src\Exslt\" >
                <Config
                    Name = "Debug"
                    EnableASPDebugging = "false"
                    EnableASPXDebugging = "false"
                    EnableUnmanagedDebugging = "false"
                    EnableSQLServerDebugging = "false"
                    RemoteDebugEnabled = "false"
                    RemoteDebugMachine = ""
                    StartAction = "Project"
                    StartArguments = ""
                    StartPage = ""
                    StartProgram = ""
                    StartURL = ""
                    StartWorkingDirectory = ""
                    StartWithIE = "false"
                />
                <Config
                    Name = "Release"
                    EnableASPDebugging = "false"
                    EnableASPXDebugging = "false"
                    EnableUnmanagedDebugging = "false"
                    EnableSQLServerDebugging = "false"
                    RemoteDebugEnabled = "false"
                    RemoteDebugMachine = ""
                    StartAction = "Project"
                    StartArguments = ""
                    StartPage = ""
                    StartProgram = ""
                    StartURL = ""
                    StartWorkingDirectory = ""
                    StartWithIE = "false"
                />
            </Settings>
        </Build>
        <OtherProjectSettings
            CopyProjectDestinationFolder = ""
            CopyProjectUncPath = ""
            CopyProjectOption = "0"
            ProjectView = "ProjectFiles"
            ProjectTrust = "0"
        />
    </CSHARP>
</VisualStudioProject>


--- NEW FILE: ExsltSetsTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for EXSLT Sets module functions.
    /// </summary>
    [TestFixture]
    public class ExsltSetsTests : ExsltUnitTests
    {        

        protected override string TestDir 
        {
            get { return "tests/EXSLT/Sets/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/EXSLT/Sets/"; }
        }   
                       
        /// <summary>
        /// Tests the following function:
        ///     set:difference()
        /// </summary>
        [Test]
        public void DifferenceTest() 
        {
            RunAndCompare("source.xml", "difference.xslt", "difference.xml");
        }
        
        /// <summary>
        /// Tests the following function:
        ///     set:intersection()
        /// </summary>
        [Test]
        public void IntersectionTest() 
        {
            RunAndCompare("source.xml", "intersection.xslt", "intersection.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     set:distinct()
        /// </summary>
        [Test]
        public void DistinctTest() 
        {
            RunAndCompare("source.xml", "distinct.xslt", "distinct.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     set:has-same-node()
        /// </summary>
        [Test]
        public void HasSameNodeTest() 
        {
            RunAndCompare("source.xml", "has-same-node.xslt", "has-same-node.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     set:leading()
        /// </summary>
        [Test]
        public void LeadingTest() 
        {
            RunAndCompare("source.xml", "leading.xslt", "leading.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     set:trailing()
        /// </summary>
        [Test]
        public void TrailingTest() 
        {
            RunAndCompare("source.xml", "trailing.xslt", "trailing.xml");
        }        
    }
}

--- NEW FILE: Mvp.Xml.Exslt.dll ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: GDNDatesAndTimesTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for GotDotNet Dates and Times module functions.
    /// </summary>
    [TestFixture]
    public class GDNDatesAndTimesTests : ExsltUnitTests
    {        
        protected override string TestDir 
        {
            get { return "tests/GotDotNet/DatesAndTimes/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/GotDotNet/DatesAndTimes/"; }
        }   
        
        /// <summary>
        /// Tests the following function:
        ///     date2:avg()
        /// </summary>
        [Test]
        public void AvgTest() 
        {
            RunAndCompare("source.xml", "avg.xslt", "avg.xml");
        } 
        
        /// <summary>
        /// Tests the following function:
        ///     date2:min()
        /// </summary>
        [Test]
        public void MinTest() 
        {
            RunAndCompare("source.xml", "min.xslt", "min.xml");
        } 

        /// <summary>
        /// Tests the following function:
        ///     date2:max()
        /// </summary>
        [Test]
        public void MaxTest() 
        {
            RunAndCompare("source.xml", "max.xslt", "max.xml");
        } 

        /// <summary>
        /// Tests the following function:
        ///     date2:day-name()
        /// </summary>
        [Test]
        public void DayNameTest() 
        {
            RunAndCompare("source.xml", "day-name.xslt", "day-name.xml");
        } 

        /// <summary>
        /// Tests the following function:
        ///     date2:day-abbreviation()
        /// </summary>
        [Test]
        public void DayAbbreviationTest() 
        {
            RunAndCompare("source.xml", "day-abbreviation.xslt", "day-abbreviation.xml");
        } 

        /// <summary>
        /// Tests the following function:
        ///     date2:month-name()
        /// </summary>
        [Test]
        public void MonthNameTest() 
        {
            RunAndCompare("source.xml", "month-name.xslt", "month-name.xml");
        } 

        /// <summary>
        /// Tests the following function:
        ///     date2:month-abbreviation()
        /// </summary>
        [Test]
        public void MonthAbbreviationTest() 
        {
            RunAndCompare("source.xml", "month-abbreviation.xslt", "month-abbreviation.xml");
        } 
    }
}

--- NEW FILE: GDNMathTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for GotDotNet Math module functions.
    /// </summary>
    [TestFixture]
    public class GDNMathTests : ExsltUnitTests
    {        
        protected override string TestDir 
        {
            get { return "tests/GotDotNet/Math/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/GotDotNet/Math/"; }
        }   
        
        /// <summary>
        /// Tests the following function:
        ///     math2:avg()
        /// </summary>
        [Test]
        public void AvgTest() 
        {
            RunAndCompare("source.xml", "avg.xslt", "avg.xml");
        }                 
    }
}

--- NEW FILE: AvailabilityTest.cmd ---
ExsltTest tests\test.xml tests\availability.xslt FunctionsAvailability.html
--- NEW FILE: ExsltTest.cs ---
using System;
using Mvp.Xml.Exslt;
using System.Xml;
using System.Xml.XPath;
using System.IO;

namespace ExsltTest
{
	/// <summary>
	/// Primitive command-line EXSLT-aware utility.
	/// </summary>
    public class ExsltTest
    {
		public static void Main(string[] args) {
		    if (args.Length != 3) {		    
		        PrintUsage();
		        return;
		    }
		    try {    
		        XPathDocument doc = new XPathDocument(args[0]);
		        ExsltTransform xslt = new ExsltTransform();		        
		        xslt.Load(args[1]);
		        xslt.MultiOutput = false;
		        using (FileStream fs = File.Create(args[2])) {
		            xslt.Transform(doc, null, fs);
		        }
		    } catch (Exception e) {
		        Console.Error.WriteLine("An exception occured: ");
		        Console.Error.WriteLine(e);
		    }
		}		
		
		private static void PrintUsage() {
		    Console.WriteLine("ExsltTest usage:");
		    Console.WriteLine("ExsltTest.exe source stylesheet result");
		}
	}
}

--- NEW FILE: ExsltMathTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for EXSLT Math module functions.
    /// </summary>
    [TestFixture]
    public class ExsltMathTests : ExsltUnitTests
    {        

        protected override string TestDir 
        {
            get { return "tests/EXSLT/Math/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/EXSLT/Math/"; }
        }   
                       
        /// <summary>
        /// Tests the following function:
        ///     math:min()
        /// </summary>
        [Test]
        public void MinTest() 
        {
            RunAndCompare("source.xml", "min.xslt", "min.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:max()
        /// </summary>
        [Test]
        public void MaxTest() 
        {
            RunAndCompare("source.xml", "max.xslt", "max.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:highest()
        /// </summary>
        [Test]
        public void HighestTest() 
        {
            RunAndCompare("source.xml", "highest.xslt", "highest.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:lowest()
        /// </summary>
        [Test]
        public void LowestTest() 
        {
            RunAndCompare("source.xml", "lowest.xslt", "lowest.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:abs()
        /// </summary>
        [Test]
        public void AbsTest() 
        {
            RunAndCompare("source.xml", "abs.xslt", "abs.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:sqrt()
        /// </summary>
        [Test]
        public void SqrtTest() 
        {
            RunAndCompare("source.xml", "sqrt.xslt", "sqrt.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:power()
        /// </summary>
        [Test]
        public void PowerTest() 
        {
            RunAndCompare("source.xml", "power.xslt", "power.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:constant()
        /// </summary>
        [Test]
        public void ConstantTest() 
        {
            RunAndCompare("source.xml", "constant.xslt", "constant.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:log()
        /// </summary>
        [Test]
        public void LogTest() 
        {
            RunAndCompare("source.xml", "log.xslt", "log.xml");
        }            
    
        /// <summary>
        /// Tests the following function:
        ///     math:random()
        /// </summary>
        [Test]
        public void RandomTest() 
        {
            RunAndCompare("source.xml", "random.xslt", "random.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:sin()
        /// </summary>
        [Test]
        public void SinTest() 
        {
            RunAndCompare("source.xml", "sin.xslt", "sin.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:cos()
        /// </summary>
        [Test]
        public void CosTest() 
        {
            RunAndCompare("source.xml", "cos.xslt", "cos.xml");
        }            
        
        /// <summary>
        /// Tests the following function:
        ///     math:tan()
        /// </summary>
        [Test]
        public void TanTest() 
        {
            RunAndCompare("source.xml", "tan.xslt", "tan.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:asin()
        /// </summary>
        [Test]
        public void AsinTest() 
        {
            RunAndCompare("source.xml", "asin.xslt", "asin.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:acos()
        /// </summary>
        [Test]
        public void AcosTest() 
        {
            RunAndCompare("source.xml", "acos.xslt", "acos.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:atan()
        /// </summary>
        [Test]
        public void AtanTest() 
        {
            RunAndCompare("source.xml", "atan.xslt", "atan.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:atan2()
        /// </summary>
        [Test]
        public void Atan2Test() 
        {
            RunAndCompare("source.xml", "atan2.xslt", "atan2.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:exp()
        /// </summary>
        [Test]
        public void ExpTest() 
        {
            RunAndCompare("source.xml", "exp.xslt", "exp.xml");
        }            
    }
}

--- NEW FILE: ExsltUnitTests.cs ---
using System;
using Mvp.Xml.Exslt;
using System.Xml;
using System.Xml.XPath;
using System.IO;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Superclass for unit tests.
    /// </summary>
    public class ExsltUnitTests
    {
        protected virtual string TestDir 
        {
            get { return "tests/EXSLT/Common/"; }
        }
        protected virtual string ResultsDir 
        {
            get { return "results/EXSLT/Common/"; }
        }

        protected void RunAndCompare(string source, string stylesheet, 
            string result) 
        {
            XPathDocument doc = new XPathDocument(TestDir + source);            
            ExsltTransform exslt = new ExsltTransform();
            exslt.Load(TestDir + stylesheet);
            StringWriter res = new StringWriter();
            exslt.Transform(doc, null, res);
            StreamReader sr = new StreamReader(ResultsDir + result);
            string expectedResult = sr.ReadToEnd();
            sr.Close();
			if (res.ToString() != expectedResult)
			{
				Console.WriteLine("Actual Result was {0}", res.ToString());
				Console.WriteLine("Expected Result was {0}", expectedResult);
			}
            Assert.IsTrue(res.ToString() == expectedResult);
        }        
    }
}

--- NEW FILE: ExsltDatesAndTimesTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for EXSLT Dates and Times module functions.
    /// </summary>
    [TestFixture]
    public class ExsltDatesAndTimesTests : ExsltUnitTests
    {        
        protected override string TestDir 
        {
            get { return "tests/EXSLT/DatesAndTimes/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/EXSLT/DatesAndTimes/"; }
        }   
        
        /// <summary>
        /// Tests the following function:
        ///     date:format-date()
        /// </summary>
        [Test]
        public void FormatDateTest() 
        {
            RunAndCompare("source.xml", "format-date.xslt", "format-date.xml");
        }                

        /// <summary>
        /// Tests the following function:
        ///     date:parse-date()
        /// </summary>
        [Test]
        public void ParseDateTest() 
        {
            RunAndCompare("source.xml", "parse-date.xslt", "parse-date.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:date-time()
        /// </summary>
        [Test]
        public void DateTimeTest() 
        {
            RunAndCompare("source.xml", "date-time.xslt", "date-time.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:date()
        /// </summary>
        [Test]
        public void DateTest() 
        {
            RunAndCompare("source.xml", "date.xslt", "date.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:time()
        /// </summary>
        [Test]
        public void TimeTest() 
        {
            RunAndCompare("source.xml", "time.xslt", "time.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:year()
        /// </summary>
        [Test]
        public void YearTest() 
        {
            RunAndCompare("source.xml", "year.xslt", "year.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:leap-year()
        /// </summary>
        [Test]
        public void LeapYearTest() 
        {
            RunAndCompare("source.xml", "leap-year.xslt", "leap-year.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:month-in-year()
        /// </summary>
        [Test]
        public void MonthInYearTest() 
        {
            RunAndCompare("source.xml", "month-in-year.xslt", "month-in-year.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:month-name()
        /// </summary>
        [Test]
        public void MonthNameTest() 
        {
            RunAndCompare("source.xml", "month-name.xslt", "month-name.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:month-abbreviation()
        /// </summary>
        [Test]
        public void MonthAbbreviationTest() 
        {
            RunAndCompare("source.xml", "month-abbreviation.xslt", "month-abbreviation.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:week-in-year()
        /// </summary>
        [Test]
        public void WeekInYearTest() 
        {
            RunAndCompare("source.xml", "week-in-year.xslt", "week-in-year.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:week-in-month()
        /// </summary>
        [Test]
        public void WeekInMonthTest() 
        {
            RunAndCompare("source.xml", "week-in-month.xslt", "week-in-month.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:day-in-year()
        /// </summary>
        [Test]
        public void DayInYearTest() 
        {
            RunAndCompare("source.xml", "day-in-year.xslt", "day-in-year.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:day-in-month()
        /// </summary>
        [Test]
        public void DayInMonthTest() 
        {
            RunAndCompare("source.xml", "day-in-month.xslt", "day-in-month.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:week-of-week-in-month()
        /// </summary>
        [Test]
        public void DayOfWeekInMonthTest() 
        {
            RunAndCompare("source.xml", "day-of-week-in-month.xslt", "day-of-week-in-month.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:day-in-week()
        /// </summary>
        [Test]
        public void DayInWeekTest() 
        {
            RunAndCompare("source.xml", "day-in-week.xslt", "day-in-week.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:day-name()
        /// </summary>
        [Test]
        public void DayNameTest() 
        {
            RunAndCompare("source.xml", "day-name.xslt", "day-name.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:day-abbreviation()
        /// </summary>
        [Test]
        public void DayAbbreviationTest() 
        {
            RunAndCompare("source.xml", "day-abbreviation.xslt", "day-abbreviation.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:hour-in-day()
        /// </summary>
        [Test]
        public void HourInDayTest() 
        {
            RunAndCompare("source.xml", "hour-in-day.xslt", "hour-in-day.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:minute-in-hour()
        /// </summary>
        [Test]
        public void MinuteInHourTest() 
        {
            RunAndCompare("source.xml", "minute-in-hour.xslt", "minute-in-hour.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:second-in-minute()
        /// </summary>
        [Test]
        public void SecondInMinuteTest() 
        {
            RunAndCompare("source.xml", "second-in-minute.xslt", "second-in-minute.xml");
        }
        
        /// <summary>
        /// Tests the following function:
        ///     date:difference()
        /// </summary>
        [Test]
        public void DifferenceTest() 
        {
            RunAndCompare("source.xml", "difference.xslt", "difference.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:add()
        /// </summary>
        [Test]
        public void AddTest() 
        {
            RunAndCompare("source.xml", "add.xslt", "add.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:add-duration()
        /// </summary>
        [Test]
        public void AddDurationTest() 
        {
            RunAndCompare("source.xml", "add-duration.xslt", "add-duration.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:sum()
        /// </summary>
        [Test]
        public void SumTest() 
        {
            RunAndCompare("source.xml", "sum.xslt", "sum.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:seconds()
        /// </summary>
        [Test]
        public void SecondsTest() 
        {
            RunAndCompare("source.xml", "seconds.xslt", "seconds.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:duration()
        /// </summary>
        [Test]
        public void DurationTest() 
        {
            RunAndCompare("source.xml", "duration.xslt", "duration.xml");
        }
    }
}

--- NEW FILE: ExsltTest.csproj ---
<VisualStudioProject>
    <CSHARP
        ProjectType = "Local"
        ProductVersion = "7.10.3077"
        SchemaVersion = "2.0"
        ProjectGuid = "{AC8B9015-E508-4E40-8E6D-C4FCF52CE4B0}"
    >
        <Build>
            <Settings
                ApplicationIcon = ""
                AssemblyKeyContainerName = ""
                AssemblyName = "ExsltTest"
                AssemblyOriginatorKeyFile = ""
                DefaultClientScript = "JScript"
                DefaultHTMLPageLayout = "Grid"
                DefaultTargetSchema = "IE50"
                DelaySign = "false"
                OutputType = "Exe"
                PreBuildEvent = ""
                PostBuildEvent = ""
                RootNamespace = "ExsltTest"
                RunPostBuildEvent = "OnBuildSuccess"
                StartupObject = ""
            >
                <Config
                    Name = "Debug"
                    AllowUnsafeBlocks = "false"
                    BaseAddress = "285212672"
                    CheckForOverflowUnderflow = "false"
                    ConfigurationOverrideFile = ""
                    DefineConstants = "DEBUG;TRACE"
                    DocumentationFile = ""
                    DebugSymbols = "true"
                    FileAlignment = "4096"
                    IncrementalBuild = "true"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "false"
                    OutputPath = ".\"
                    RegisterForComInterop = "false"
                    RemoveIntegerChecks = "false"
                    TreatWarningsAsErrors = "false"
                    WarningLevel = "4"
                />
                <Config
                    Name = "Release"
                    AllowUnsafeBlocks = "false"
                    BaseAddress = "285212672"
                    CheckForOverflowUnderflow = "false"
                    ConfigurationOverrideFile = ""
                    DefineConstants = "TRACE"
                    DocumentationFile = ""
                    DebugSymbols = "false"
                    FileAlignment = "4096"
                    IncrementalBuild = "false"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "true"
                    OutputPath = ".\"
                    RegisterForComInterop = "false"
                    RemoveIntegerChecks = "false"
                    TreatWarningsAsErrors = "false"
                    WarningLevel = "4"
                />
            </Settings>
            <References>
                <Reference
                    Name = "System"
                    AssemblyName = "System"
                    HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.0.3705\System.dll"
                />
                <Reference
                    Name = "System.Data"
                    AssemblyName = "System.Data"
                    HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.0.3705\System.Data.dll"
                />
                <Reference
                    Name = "System.XML"
                    AssemblyName = "System.Xml"
                    HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.0.3705\System.XML.dll"
                />
                <Reference
                    Name = "nunit.framework"
                    AssemblyName = "nunit.framework"
                    HintPath = "..\..\..\Program Files\NUnit 2.2\bin\nunit.framework.dll"
                    AssemblyFolderKey = "hklm\dn\nunit.framework"
                />
                <Reference
                    Name = "Mvp.Xml.Exslt"
                    AssemblyName = "Mvp.Xml.Exslt"
                    HintPath = "..\..\src\Exslt\Mvp.Xml.Exslt.dll"
                />
            </References>
        </Build>
        <Files>
            <Include>
                <File
                    RelPath = "AssemblyInfo.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "AvailabilityTest.cmd"
                    BuildAction = "None"
                />
                <File
                    RelPath = "ExsltCommonTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "ExsltDatesAndTimesTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "ExsltMathTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "ExsltRandomTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "ExsltRegularExpressionsTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "ExsltSetsTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "ExsltStringsTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "ExsltTest.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "ExsltUnitTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "GDNDatesAndTimesTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "GDNDynamicTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "GDNMathTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "GDNRegularExpressionsTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "GDNSetsTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "GDNStringsTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "Makefile"
                    BuildAction = "None"
                />
                <File
                    RelPath = "results\EXSLT\Common\node-set.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Common\object-type.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\add.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\add-duration.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\date.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\date-time.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\day-abbreviation.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\day-in-month.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\day-in-week.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\day-in-year.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\day-name.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\day-of-week-in-month.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\difference.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\duration.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\format-date.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\hour-in-day.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\leap-year.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\minute-in-hour.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\month-abbreviation.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\month-in-year.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\month-name.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\parse-date.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\second-in-minute.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\seconds.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\sum.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\time.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\week-in-month.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\week-in-year.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\DatesAndTimes\year.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\abs.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\acos.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\asin.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\atan.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\atan2.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\constant.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\cos.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\exp.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\highest.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\log.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\lowest.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\max.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\min.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\power.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\random.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\sin.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\sqrt.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Math\tan.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Random\random-sequence.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\RegularExpressions\match.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\RegularExpressions\replace.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\RegularExpressions\test.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Sets\difference.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Sets\distinct.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Sets\has-same-node.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Sets\intersection.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Sets\leading.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Sets\trailing.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Strings\align.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Strings\concat.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Strings\decode-uri.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Strings\encode-uri.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Strings\padding.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Strings\replace.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Strings\split.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\EXSLT\Strings\tokenize.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\GotDotNet\DatesAndTimes\avg.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\GotDotNet\DatesAndTimes\day-abbreviation.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\GotDotNet\DatesAndTimes\day-name.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\GotDotNet\DatesAndTimes\max.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\GotDotNet\DatesAndTimes\min.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\GotDotNet\DatesAndTimes\month-abbreviation.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\GotDotNet\DatesAndTimes\month-name.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\GotDotNet\Dynamic\evaluate.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\GotDotNet\Math\avg.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\GotDotNet\RegularExpressions\tokenize.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\GotDotNet\Sets\subset.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\GotDotNet\Strings\lowercase.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "results\GotDotNet\Strings\uppercase.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\availability.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\invoice.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\invoice-processor.xsl"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\regexp-match-test.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\test.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\Common\node-set.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\Common\object-type.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\Common\source.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\add.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\add-duration.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\date.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\date-time.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\day-abbreviation.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\day-in-month.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\day-in-week.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\day-in-year.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\day-name.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\day-of-week-in-month.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\difference.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\duration.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\format-date.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\hour-in-day.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\leap-year.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\minute-in-hour.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\month-abbreviation.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\month-in-year.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\month-name.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\parse-date.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\second-in-minute.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\seconds.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\source.xml"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\sum.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\time.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\week-in-month.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\week-in-year.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\DatesAndTimes\year.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\Math\abs.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\Math\acos.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\Math\asin.xslt"
                    BuildAction = "Content"
                />
                <File
                    RelPath = "tests\EXSLT\Math\atan.xslt"
                    BuildAction = "Content"
                />
          ...
 
[truncated message content]

[mvp-xml-cvs] EXSLT/v1/src/MethodRenamer/obj/Debug MethodRenamer.exe,NONE,1.1 MethodRenamer.exe.incr,NONE,1.1 MethodRenamer.projdata,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/src/MethodRenamer/obj/Debug
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/src/MethodRenamer/obj/Debug

Added Files:
	MethodRenamer.exe MethodRenamer.exe.incr 
	MethodRenamer.projdata 
Log Message:


--- NEW FILE: MethodRenamer.exe ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: MethodRenamer.exe.incr ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: MethodRenamer.projdata ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/test/ExsltTest/obj/Debug ExsltTest.dll,NONE,1.1 ExsltTest.dll.incr,NONE,1.1 ExsltTest.exe,NONE,1.1 ExsltTest.exe.incr,NONE,1.1 ExsltTest.projdata,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltTest/obj/Debug
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/test/ExsltTest/obj/Debug

Added Files:
	ExsltTest.dll ExsltTest.dll.incr ExsltTest.exe 
	ExsltTest.exe.incr ExsltTest.projdata 
Log Message:


--- NEW FILE: ExsltTest.exe ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: ExsltTest.dll.incr ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: ExsltTest.dll ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: ExsltTest.exe.incr ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: ExsltTest.projdata ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/test/ExsltTest/results/EXSLT/Common node-set.xml,NONE,1.1 object-type.xml,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltTest/results/EXSLT/Common
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/test/ExsltTest/results/EXSLT/Common

Added Files:
	node-set.xml object-type.xml 
Log Message:


--- NEW FILE: object-type.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: node-set.xml ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/test/ExsltTest/results/EXSLT/DatesAndTimes add-duration.xml,NONE,1.1 add.xml,NONE,1.1 date-time.xml,NONE,1.1 date.xml,NONE,1.1 day-abbreviation.xml,NONE,1.1 day-in-month.xml,NONE,1.1 day-in-week.xml,NONE,1.1 day-in-year.xml,NONE,1.1 day-name.xml,NONE,1.1 day-of-week-in-month.xml,NONE,1.1 difference.xml,NONE,1.1 duration.xml,NONE,1.1 format-date.xml,NONE,1.1 hour-in-day.xml,NONE,1.1 leap-year.xml,NONE,1.1 minute-in-hour.xml,NONE,1.1 month-abbreviation.xml,NONE,1.1 month-in-year.xml,NONE,1.1 month-name.xml,NONE,1.1 parse-date.xml,NONE,1.1 second-in-minute.xml,NONE,1.1 seconds.xml,NONE,1.1 sum.xml,NONE,1.1 time.xml,NONE,1.1 week-in-month.xml,NONE,1.1 week-in-year.xml,NONE,1.1 year.xml,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltTest/results/EXSLT/DatesAndTimes
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/test/ExsltTest/results/EXSLT/DatesAndTimes

Added Files:
	add-duration.xml add.xml date-time.xml date.xml 
	day-abbreviation.xml day-in-month.xml day-in-week.xml 
	day-in-year.xml day-name.xml day-of-week-in-month.xml 
	difference.xml duration.xml format-date.xml hour-in-day.xml 
	leap-year.xml minute-in-hour.xml month-abbreviation.xml 
	month-in-year.xml month-name.xml parse-date.xml 
	second-in-minute.xml seconds.xml sum.xml time.xml 
	week-in-month.xml week-in-year.xml year.xml 
Log Message:


--- NEW FILE: duration.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: difference.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: sum.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: add-duration.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: day-of-week-in-month.xml ---
<out>
  <test1>1</test1>
  <test2>NaN</test2>
</out>
--- NEW FILE: parse-date.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: time.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: day-abbreviation.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: add.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: month-in-year.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: day-in-month.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: minute-in-hour.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: week-in-month.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: second-in-minute.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: date.xml ---
<out>
  <test1>2001-07-04+02:00</test1>
  <test2></test2>
  <test3>2001-09-12</test3>
</out>
--- NEW FILE: year.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: day-name.xml ---
<out>
  <test1>Wednesday</test1>
  <test2></test2>
  <test3>Sunday</test3>
  <test4>Monday</test4>
  <test5>Tuesday</test5>
  <test6>Wednesday</test6>
  <test7>Thursday</test7>
  <test8>Friday</test8>
  <test9>Saturday</test9>
</out>
--- NEW FILE: format-date.xml ---
<out>
  <test1>2001.07.04 AD 12:08:56 GMT+02:00</test1>
  <test2>Wed, Jul 4, 2001</test2>
  <test3>12:08 PM</test3>
  <test4>12 PM, GMT+02:00</test4>
  <test5>0:08 PM, GMT+02:00</test5>
  <test6>02001.July.04 AD 12:08 PM</test6>
  <test7>Wed, 4 Jul 2001 12:08:56 +0200</test7>
  <test8>010704120856+0200</test8>
  <test9></test9>
  <test10></test10>
</out>
--- NEW FILE: day-in-week.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: seconds.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: month-abbreviation.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: hour-in-day.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: day-in-year.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: week-in-year.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: month-name.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: leap-year.xml ---
<out>
  <test1>false</test1>
  <test2>true</test2>
  <test3>false</test3>
  <test4>true</test4>
  <test5>false</test5>
</out>
--- NEW FILE: date-time.xml ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/src/Exslt .cvsignore,NONE,1.1 AssemblyInfo.cs,NONE,1.1 Exslt.csproj,NONE,1.1 Exslt.csproj.user,NONE,1.1 Exslt.csproj.vspscc,NONE,1.1 ExsltCommon.cs,NONE,1.1 ExsltContext.cs,NONE,1.1 ExsltContextFunction.cs,NONE,1.1 ExsltDatesAndTimes.cs,NONE,1.1 ExsltMath.cs,NONE,1.1 ExsltNamespaces.cs,NONE,1.1 ExsltNodeList.cs,NONE,1.1 ExsltRandom.cs,NONE,1.1 ExsltRegularExpressions.cs,NONE,1.1 ExsltSets.cs,NONE,1.1 ExsltStrings.cs,NONE,1.1 ExsltTransform.cs,NONE,1.1 GDNDatesAndTimes.cs,NONE,1.1 GDNDynamic.cs,NONE,1.1 GDNMath.cs,NONE,1.1 GDNRegularExpressions.cs,NONE,1.1 GDNSets.cs,NONE,1.1 GDNStrings.cs,NONE,1.1 Makefile,NONE,1.1 MethodRenamer.exe,NONE,1.1 MethodRenamer.exe.config,NONE,1.1 Mvp.Xml.Exslt.dll,NONE,1.1 PostBuildEvent.bat,NONE,1.1 ReadMe.htm,NONE,1.1 index.html,NONE,1.1 install.cmd,NONE,1.1 uninstall.cmd,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/src/Exslt
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/src/Exslt

Added Files:
	.cvsignore AssemblyInfo.cs Exslt.csproj Exslt.csproj.user 
	Exslt.csproj.vspscc ExsltCommon.cs ExsltContext.cs 
	ExsltContextFunction.cs ExsltDatesAndTimes.cs ExsltMath.cs 
	ExsltNamespaces.cs ExsltNodeList.cs ExsltRandom.cs 
	ExsltRegularExpressions.cs ExsltSets.cs ExsltStrings.cs 
	ExsltTransform.cs GDNDatesAndTimes.cs GDNDynamic.cs GDNMath.cs 
	GDNRegularExpressions.cs GDNSets.cs GDNStrings.cs Makefile 
	MethodRenamer.exe MethodRenamer.exe.config Mvp.Xml.Exslt.dll 
	PostBuildEvent.bat ReadMe.htm index.html install.cmd 
	uninstall.cmd 
Log Message:


--- NEW FILE: ExsltNamespaces.cs ---
namespace Mvp.Xml.Exslt {
	/// <summary>
	/// Exslt (and other) namespaces constants.
	/// </summary>
	public class ExsltNamespaces {
		public const string Common = "http://exslt.org/common";
		public const string DatesAndTimes = "http://exslt.org/dates-and-times";
		public const string Math = "http://exslt.org/math";
		public const string Random = "http://exslt.org/random";
		public const string RegularExpressions = "http://exslt.org/regular-expressions";
		public const string Sets = "http://exslt.org/sets";
		public const string Strings = "http://exslt.org/strings";
		public const string GDNDatesAndTimes = "http://gotdotnet.com/exslt/dates-and-times";
		public const string GDNMath = "http://gotdotnet.com/exslt/math";
		public const string GDNRegularExpressions = "http://gotdotnet.com/exslt/regular-expressions";
		public const string GDNSets = "http://gotdotnet.com/exslt/sets";
		public const string GDNStrings = "http://gotdotnet.com/exslt/strings";
        public const string GDNDynamic = "http://gotdotnet.com/exslt/dynamic";
	}    
}
--- NEW FILE: uninstall.cmd ---
gacutil /u Mvp.Xml.Exslt
--- NEW FILE: GDNStrings.cs ---
namespace Mvp.Xml.Exslt {
    /// <summary>
    ///   This class implements additional functions in the http://gotdotnet.com/exslt/strings namespace.
    /// </summary>		
    public class GDNStrings {
        /// <summary>
        /// Implements the following function 
        ///		string uppercase(string)
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        /// <remarks>THIS FUNCTION IS NOT IN EXSLT!!!</remarks>
        public string uppercase(string str)
        {
            return str.ToUpper(); 
        }

        /// <summary>
        /// Implements the following function 
        ///		string lowercase(string)
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        /// <remarks>THIS FUNCTION IS NOT IN EXSLT!!!</remarks>
        public string lowercase(string str)
        {
            return str.ToLower(); 
        }		        
    }   
}

--- NEW FILE: ExsltMath.cs ---
#region using

using System;
using System.Xml;
using System.Xml.XPath;

#endregion

namespace Mvp.Xml.Exslt
{
	/// <summary>
	/// This class implements the EXSLT functions in the http://exslt.org/math namespace.
	/// </summary>
	public class ExsltMath {
		/// <summary>
		/// Implements the following function 
		///    number min(node-set)
		/// </summary>
		/// <param name="iterator"></param>
		/// <returns></returns>        
		public double min(XPathNodeIterator iterator){

			double min, t; 

			if(iterator.Count == 0){
				return Double.NaN; 
			}

			try{ 

				iterator.MoveNext(); 
				min = XmlConvert.ToDouble(iterator.Current.Value);

			
				while(iterator.MoveNext()){
					t = XmlConvert.ToDouble(iterator.Current.Value);
					min = (t < min)? t : min; 
				}
				
			}catch(Exception){
				return Double.NaN; 
			}		

			return min; 
		}

		
		/// <summary>
		/// Implements the following function 
		///    number max(node-set)
		/// </summary>
		/// <param name="iterator"></param>
		/// <returns></returns>		
		public double max(XPathNodeIterator iterator){

			double max, t; 

			if(iterator.Count == 0){
				return Double.NaN; 
			}

			try{ 

				iterator.MoveNext(); 
				max = XmlConvert.ToDouble(iterator.Current.Value);

			
				while(iterator.MoveNext()){
					t = XmlConvert.ToDouble(iterator.Current.Value);
					max = (t > max)? t : max; 
				}
				
			}catch(Exception){
				return Double.NaN; 
			}		

			return max; 
		}
		

		/// <summary>
		/// Implements the following function 
		///    node-set highest(node-set)
		/// </summary>
		/// <param name="iterator">The input nodeset</param>
		/// <returns>All the nodes that contain the max value in the nodeset</returns>		
		public XPathNodeIterator highest(XPathNodeIterator iterator){

			ExsltNodeList newList = new ExsltNodeList(); 
			double max, t; 

			if(iterator.Count == 0){
				return ExsltCommon.ExsltNodeListToXPathNodeIterator(newList);  
			}


			try{ 

				iterator.MoveNext(); 
				max = XmlConvert.ToDouble(iterator.Current.Value);
				newList.Add(iterator.Current.Clone()); 

				while (iterator.MoveNext()){
					t = XmlConvert.ToDouble(iterator.Current.Value);
				
					if(t > max){
						max =  t;
						newList.Clear(); 
						newList.Add(iterator.Current.Clone()); 
					}else if( t == max){
						newList.Add(iterator.Current.Clone()); 
					}
				}
				
			}catch(Exception){ //return empty node set
				newList.Clear(); 
				return ExsltCommon.ExsltNodeListToXPathNodeIterator(newList);  
			}

			return ExsltCommon.ExsltNodeListToXPathNodeIterator(newList); 
		}


		/// <summary>
		/// Implements the following function 
		///    node-set lowest(node-set)
		/// </summary>
		/// <param name="iterator">The input nodeset</param>
		/// <returns>All the nodes that contain the min value in the nodeset</returns>		
		public XPathNodeIterator lowest(XPathNodeIterator iterator){

			ExsltNodeList newList = new ExsltNodeList(); 
			double min, t; 

			if(iterator.Count == 0){
				return ExsltCommon.ExsltNodeListToXPathNodeIterator(newList);  
			}


			try{ 

				iterator.MoveNext(); 
				min = XmlConvert.ToDouble(iterator.Current.Value);
				newList.Add(iterator.Current.Clone()); 

				while (iterator.MoveNext()){
					t = XmlConvert.ToDouble(iterator.Current.Value);
				
					if(t < min){
						min =  t;
						newList.Clear(); 
						newList.Add(iterator.Current.Clone()); 
					}else if( t == min){
						newList.Add(iterator.Current.Clone()); 
					}
				}
				
			}catch(Exception){ //return empty node set
				newList.Clear(); 
				return ExsltCommon.ExsltNodeListToXPathNodeIterator(newList);  
			}

			return ExsltCommon.ExsltNodeListToXPathNodeIterator(newList); 
		}

		/// <summary>
		///  Implements the following function 
		///     number abs(number)
		/// </summary>
		/// <param name="number"></param>
		/// <returns></returns>
		public double abs(double number){

			return Math.Abs(number); 
		}	

		/// <summary>
		///  Implements the following function 
		///     number sqrt(number)
		/// </summary>
		/// <param name="number"></param>
		/// <returns></returns>
		public double sqrt(double number){

            if (number < 0)
                return 0;
			return Math.Sqrt(number); 
		}

		/// <summary>
		///  Implements the following function 
		///     number power(number, number)
		/// </summary>
		/// <param name="x"></param>
		/// <param name="y"></param>
		/// <returns></returns>
		public double power(double x, double y){

			return Math.Pow(x, y); 
		}

		/// <summary>
		///  Implements the following function 
		///     number log(number)
		/// </summary>
		/// <param name="x"></param>
		/// <returns></returns>
		public double log(double x){

			return Math.Log(x); 
		}

		/// <summary>
		///  Implements the following function 
		///     number constant(string, number)
		/// </summary>
		/// <param name="number"></param>
		/// <returns>The specified constant or NaN</returns>
		/// <remarks>This method only supports the constants 
		/// E and PI. Also the precision parameter is ignored.</remarks>
		public double constant(string c, double precision){
            switch(c.ToUpper()) {                       
                case "E":
                    return Math.E;
                case "PI":
                    return Math.PI;
                case "SQRRT2" :
                    return Math.Sqrt(2);
                case "LN2" :
                    return Math.Log(2);
                case "LN10" :
                    return Math.Log(10);
                case "LOG2E" :
                    return Math.Log(Math.E, 2);
                case "SQRT1_2" :
                    return Math.Sqrt(.5);
                default:
                    return Double.NaN;
            }
		}

		/// <summary>
		///  Implements the following function 
		///     number random()
		/// </summary>
		/// <param name="x"></param>
		/// <returns></returns>
		public double random(){

			Random rand = new Random((int) DateTime.Now.Ticks); 
			return rand.NextDouble(); 
		}

		/// <summary>
		///  Implements the following function 
		///     number sin(number)
		/// </summary>
		/// <param name="x"></param>
		/// <returns></returns>
		public double sin(double x){

			return Math.Sin(x); 
		}

		/// <summary>
		///  Implements the following function 
		///     number asin(number)
		/// </summary>
		/// <param name="x"></param>
		/// <returns></returns>
		public double asin(double x){

			return Math.Asin(x); 
		}


		/// <summary>
		///  Implements the following function 
		///     number cos(number)
		/// </summary>
		/// <param name="x"></param>
		/// <returns></returns>
		public double cos(double x){

			return Math.Cos(x); 
		}

		/// <summary>
		///  Implements the following function 
		///     number acos(number)
		/// </summary>
		/// <param name="x"></param>
		/// <returns></returns>
		public double acos(double x){

			return Math.Acos(x); 
		}

		/// <summary>
		///  Implements the following function 
		///     number tan(number)
		/// </summary>
		/// <param name="x"></param>
		/// <returns></returns>
		public double tan(double x){

			return Math.Tan(x); 
		}

		/// <summary>
		///  Implements the following function 
		///     number atan(number)
		/// </summary>
		/// <param name="x"></param>
		/// <returns></returns>
		public double atan(double x){

			return Math.Atan(x); 
		}

		/// <summary>
		///  Implements the following function 
		///     number atan2(number, number)
		/// </summary>
		/// <param name="x"></param>
		/// <param name="y"></param>
		/// <returns></returns>
		public double atan2(double x, double y){

			return Math.Atan2(x,y); 
		}

		/// <summary>
		///  Implements the following function 
		///     number exp(number)
		/// </summary>
		/// <param name="x"></param>
		/// <returns></returns>
		public double exp(double x){

			return Math.Exp(x); 
		}		
	}
}


--- NEW FILE: MethodRenamer.exe.config ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: ExsltRandom.cs ---
#region using

using System;
using System.Xml.XPath;
using System.Xml;

#endregion

namespace Mvp.Xml.Exslt
{
	/// <summary>
	/// This class implements the EXSLT functions in the http://exslt.org/random namespace.
	/// </summary>
	public class ExsltRandom
	{
		/// <summary>
		///  Implements the following function 
		///     number+ random:random-sequence(number?, number?)
		/// </summary>				
		public XPathNodeIterator randomSequence()
		{	
			return randomSequenceImpl(1, (int)DateTime.Now.Ticks);
		}

		/// <summary>
		/// This wrapper method will be renamed during custom build 
		/// to provide conformant EXSLT function name.
		/// </summary>	
		public XPathNodeIterator randomSequence_RENAME_ME() 
		{
			return randomSequence();
		}
			
		/// <summary>
		///  Implements the following function 
		///     number+ random:random-sequence(number?, number?)
		/// </summary>	
		public XPathNodeIterator randomSequence(double number) 
		{	
		
			return randomSequenceImpl(number, (int)DateTime.Now.Ticks);
		}

		/// <summary>
		/// This wrapper method will be renamed during custom build 
		/// to provide conformant EXSLT function name.
		/// </summary>	
		public XPathNodeIterator randomSequence_RENAME_ME(double number) 
		{
			return randomSequence(number);
		}

		/// <summary>
		///  Implements the following function 
		///     number+ random:random-sequence(number?, number?)
		/// </summary>
		public XPathNodeIterator randomSequence(double number, double seed) 
		{			
			return randomSequenceImpl(number, (int)(seed % int.MaxValue));
		}

		/// <summary>
		/// This wrapper method will be renamed during custom build 
		/// to provide conformant EXSLT function name.
		/// </summary>	
		public XPathNodeIterator randomSequence_RENAME_ME(double number, double seed) 
		{
			return randomSequence(number, seed);
		}

		/// <summary>
		/// random-sequence() implementation;
		/// </summary>
		/// <param name="number"></param>
		/// <param name="seed"></param>
		/// <returns></returns>
		private XPathNodeIterator randomSequenceImpl(double number, int seed) 
		{
			XmlDocument doc = new XmlDocument(); 
			doc.LoadXml("<randoms/>");

			Random rand = new Random(seed);
            
            //Negative number is bad idea - fallback to default
            if (number < 0)
                number = 1;

            //we limit number of generated numbers to int.MaxValue
            if (number > int.MaxValue)
                number = int.MaxValue;
			for (int i=0; i<Convert.ToInt32(number); i++)
			{			
				XmlElement elem = doc.CreateElement("random"); 
				elem.InnerText  =  rand.NextDouble().ToString();
				doc.DocumentElement.AppendChild(elem); 
			}

			return doc.CreateNavigator().Select("/randoms/random"); 
		}
	}
}

--- NEW FILE: Makefile ---
all:            
	@echo off
        @echo ########### Building Exslt library...        
        csc /out:Mvp.Xml.Exslt.dll /target:library *.cs MultiOutput\*.cs /debug- /optimize+         
        nmake rename-methods
        
rename-methods:
        @echo ########### Disassembing...
        ildasm Mvp.Xml.Exslt.dll  /out=Mvp.Xml.Exslt.il /nobar
        @echo ########### Renaming methods...	
        MethodRenamer.exe Mvp.Xml.Exslt.il Mvp.Xml.Exslt.Fixed.il
        @echo ########### Assembling library back...
        ilasm Mvp.Xml.Exslt.Fixed.il /RESOURCE=Mvp.Xml.Exslt.res  /DLL /OUTPUT=Mvp.Xml.Exslt.dll /KEY=../../../../Global/v1/mvp-xml.snk
        nmake clean

clean:
        @echo ########### Cleaning...
        del Mvp.Xml.Exslt.res
        del Mvp.Xml.Exslt.il
        del Mvp.Xml.Exslt.Fixed.il

--- NEW FILE: ExsltDatesAndTimes.cs ---
#region using

using System;
using System.Globalization;
using System.Xml;
using System.Xml.XPath;
using System.Text;
using System.Text.RegularExpressions;

#endregion

namespace Mvp.Xml.Exslt
{
	/// <summary>
	/// This class implements the EXSLT functions in the http://exslt.org/dates-and-times namespace.
	/// </summary>
	public class ExsltDatesAndTimes
	{
		private CultureInfo ci = new CultureInfo("en-US");
[...2135 lines suppressed...]
		///    string date:duration()
		/// </summary>
		/// <returns>seconds since the beginning of the epoch until now</returns>        
		public string duration()
		{
			return duration(seconds()); 
		}

		/// <summary>
		/// Implements the following function 
		///    string date:duration(number)
		/// </summary>
		/// <param name="seconds"></param>
		/// <returns></returns>        
		public string duration(double seconds)
		{
			return XmlConvert.ToString(new TimeSpan(0,0,(int)seconds)); 
		}	
	}
}

--- NEW FILE: GDNDatesAndTimes.cs ---
#region using

using System;
using System.Globalization;
using System.Xml;
using System.Xml.XPath;

#endregion

namespace Mvp.Xml.Exslt
{
    /// <summary>
    /// This class implements additional functions in the 
    /// "http://gotdotnet.com/exslt/dates-and-times" namespace.    
    /// </summary>
    public class GDNDatesAndTimes : ExsltDatesAndTimes
    {                   
      
        #region date2:avg()
        /// <summary>
        /// Implements the following function 
        ///    string date2:avg(node-set)
        /// See http://www.xmland.net/exslt/doc/GDNDatesAndTimes-avg.xml  
        /// </summary>        
        /// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>
        public string avg(XPathNodeIterator iterator)
        {
            TimeSpan sum = new TimeSpan(0,0,0,0); 
            int count = iterator.Count;
            if(count == 0)
            {
                return ""; 
            }
            try
            { 
                while(iterator.MoveNext())
                {
                    sum = XmlConvert.ToTimeSpan(iterator.Current.Value).Add(sum);
                }
				
            }
            catch(FormatException)
            {
                return ""; 
            }			 

            return duration(sum.TotalSeconds / count); 
        }

        #endregion

        #region date2:min()
        /// <summary>
        /// Implements the following function 
        ///    string date2:min(node-set)
        /// See http://www.xmland.net/exslt/doc/GDNDatesAndTimes-min.xml
        /// </summary>        
        /// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>
        public string min(XPathNodeIterator iterator)
        {

            TimeSpan min, t; 

            if(iterator.Count == 0)
            {
                return ""; 
            }

            try
            { 

                iterator.MoveNext(); 
                min = XmlConvert.ToTimeSpan(iterator.Current.Value);
			
                while(iterator.MoveNext())
                {
                    t = XmlConvert.ToTimeSpan(iterator.Current.Value);
                    min = (t < min)? t : min; 
                }
				
            }
            catch(FormatException)
            {
                return ""; 
            }		

            return XmlConvert.ToString(min); 
        }

        #endregion
		  
        #region date2:max()

        /// <summary>
        /// Implements the following function 
        ///    string date2:max(node-set)
        /// See http://www.xmland.net/exslt/doc/GDNDatesAndTimes-max.xml
        /// </summary>        
        /// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>
        public string max(XPathNodeIterator iterator)
        {

            TimeSpan max, t; 

            if(iterator.Count == 0)
            {
                return ""; 
            }
	
            try
            { 

                iterator.MoveNext(); 
                max = XmlConvert.ToTimeSpan(iterator.Current.Value);

			
                while(iterator.MoveNext())
                {
                    t = XmlConvert.ToTimeSpan(iterator.Current.Value);
                    max = (t > max)? t : max; 
                }
				
            }
            catch(FormatException)
            {
                return ""; 
            }		

            return XmlConvert.ToString(max); 
        }
        #endregion

        #region date2:day-abbreviation()
        
        /// <summary>
        /// This wrapper method will be renamed during custom build 
        /// to provide conformant EXSLT function name.
        /// </summary>
        public string dayAbbreviation_RENAME_ME(string d, string c) 
        {
            return dayAbbreviation(d, c);
        }

        /// <summary>
        /// This wrapper method will be renamed during custom build 
        /// to provide conformant EXSLT function name.
        /// </summary>
        public new string dayAbbreviation_RENAME_ME(string c) 
        {
            return dayAbbreviation(c);
        }

        /// <summary>
        /// Implements the following function 
        ///    string date2:day-abbreviation(string)
        /// See http://www.xmland.net/exslt/doc/GDNDatesAndTimes-day-abbreviation.xml
        /// </summary>        
        /// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>    
        /// <returns>The abbreviated current day name according to 
        /// specified culture or the empty string if the culture isn't 
        /// supported.</returns>
        public new string dayAbbreviation(string culture)
        {
            try
            {                
                CultureInfo ci = new CultureInfo(culture);
                return ci.DateTimeFormat.GetAbbreviatedDayName(DateTime.Now.DayOfWeek);
            }
            catch (Exception)
            {
                return ""; 
            }            
        }

        /// <summary>
        /// Implements the following function 
        ///    string date2:day-abbreviation(string, string)
        /// See http://www.xmland.net/exslt/doc/GDNDatesAndTimes-day-abbreviation.xml
        /// </summary>        
        /// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>    
        /// <returns>The abbreviated day name of the specified date according to 
        /// specified culture or the empty string if the input date is invalid or
        /// the culture isn't supported.</returns>
        public string dayAbbreviation(string d, string culture)
        {
            try
            {
                DateTZ date = new DateTZ(d); 
                CultureInfo ci = new CultureInfo(culture);
                return ci.DateTimeFormat.GetAbbreviatedDayName(date.d.DayOfWeek);
            }
            catch (Exception)
            {
                return ""; 
            }            
        }    

        #endregion 

        #region date2:day-name()
    
        /// <summary>
        /// This wrapper method will be renamed during custom build 
        /// to provide conformant EXSLT function name.
        /// </summary>
        public string dayName_RENAME_ME(string d, string c) 
        {
            return dayName(d, c);
        }

        /// <summary>
        /// This wrapper method will be renamed during custom build 
        /// to provide conformant EXSLT function name.
        /// </summary>
        public new string dayName_RENAME_ME(string c) 
        {
            return dayName(c);
        }

        /// <summary>
        /// Implements the following function 
        ///    string date2:day-name(string, string?)
        /// See http://www.xmland.net/exslt/doc/GDNDatesAndTimes-day-name.xml
        /// </summary>        
        /// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>    
        /// <returns>The day name of the specified date according to 
        /// specified culture or the empty string if the input date is invalid or
        /// the culture isn't supported.</returns>
        public string dayName(string d, string culture)
        {
            try
            {                
                DateTZ date = new DateTZ(d);
                CultureInfo ci = new CultureInfo(culture);
                return ci.DateTimeFormat.GetDayName(date.d.DayOfWeek);
            }
            catch (Exception)
            {
                return ""; 
            }            
        }

        /// <summary>
        /// Implements the following function 
        ///    string date2:day-name(string, string?)
        /// See http://www.xmland.net/exslt/doc/GDNDatesAndTimes-day-name.xml
        /// </summary>        
        /// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>    
        /// <returns>The day name of the current date according to 
        /// specified culture or the empty string if
        /// the culture isn't supported.</returns>
        public new string dayName(string culture)
        {
            try
            {                                
                CultureInfo ci = new CultureInfo(culture);
                return ci.DateTimeFormat.GetDayName(DateTime.Now.DayOfWeek);
            }
            catch (Exception)
            {
                return ""; 
            }            
        }
        
        #endregion 
      
        #region date2:month-abbreviation()
        
        /// <summary>
        /// This wrapper method will be renamed during custom build 
        /// to provide conformant EXSLT function name.
        /// </summary>
        public string monthAbbreviation_RENAME_ME(string d, string c) 
        {
            return monthAbbreviation(d, c);
        }

        /// <summary>
        /// This wrapper method will be renamed during custom build 
        /// to provide conformant EXSLT function name.
        /// </summary>
        public new string monthAbbreviation_RENAME_ME(string c) 
        {
            return monthAbbreviation(c);
        }

        /// <summary>
        /// Implements the following function 
        ///    string date2:month-abbreviation(string)
        /// See http://www.xmland.net/exslt/doc/GDNDatesAndTimes-month-abbreviation.xml
        /// </summary>        
        /// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>    
        /// <returns>The abbreviated current month name according to 
        /// specified culture or the empty string if the culture isn't 
        /// supported.</returns>
        public new string monthAbbreviation(string culture)
        {
            try
            {                
                CultureInfo ci = new CultureInfo(culture);
                return ci.DateTimeFormat.GetAbbreviatedMonthName(DateTime.Now.Month);
            }
            catch (Exception)
            {
                return ""; 
            }            
        }

        /// <summary>
        /// Implements the following function 
        ///    string date2:month-abbreviation(string, string)
        /// See http://www.xmland.net/exslt/doc/GDNDatesAndTimes-month-abbreviation.xml
        /// </summary>        
        /// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>    
        /// <returns>The abbreviated month name of the specified date according to 
        /// specified culture or the empty string if the input date is invalid or
        /// the culture isn't supported.</returns>
        public string monthAbbreviation(string d, string culture)
        {
            try
            {
                DateTZ date = new DateTZ(d); 
                CultureInfo ci = new CultureInfo(culture);
                return ci.DateTimeFormat.GetAbbreviatedMonthName(date.d.Month);
            }
            catch (Exception)
            {
                return ""; 
            }            
        }    

        #endregion

        #region date2:month-name()
            
        /// <summary>
        /// This wrapper method will be renamed during custom build 
        /// to provide conformant EXSLT function name.
        /// </summary>
        public string monthName_RENAME_ME(string d, string c) 
        {
            return monthName(d, c);
        }

        /// <summary>
        /// This wrapper method will be renamed during custom build 
        /// to provide conformant EXSLT function name.
        /// </summary>
        public new string monthName_RENAME_ME(string c) 
        {
            return monthName(c);
        }

        /// <summary>
        /// Implements the following function 
        ///    string date2:month-name(string, string?)
        /// See http://www.xmland.net/exslt/doc/GDNDatesAndTimes-month-name.xml
        /// </summary>        
        /// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>    
        /// <returns>The month name of the specified date according to 
        /// specified culture or the empty string if the input date is invalid or
        /// the culture isn't supported.</returns>
        public string monthName(string d, string culture)
        {
            try
            {                
                DateTZ date = new DateTZ(d);
                CultureInfo ci = new CultureInfo(culture);
                return ci.DateTimeFormat.GetMonthName(date.d.Month);
            }
            catch (Exception)
            {
                return ""; 
            }            
        }

        /// <summary>
        /// Implements the following function 
        ///    string date2:month-name(string, string?)
        /// See http://www.xmland.net/exslt/doc/GDNDatesAndTimes-month-name.xml
        /// </summary>        
        /// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>    
        /// <returns>The month name of the current date according to 
        /// specified culture or the empty string if
        /// the culture isn't supported.</returns>
        public new string monthName(string culture)
        {
            try
            {                                
                CultureInfo ci = new CultureInfo(culture);
                return ci.DateTimeFormat.GetMonthName(DateTime.Now.Month);
            }
            catch (Exception)
            {
                return ""; 
            }            
        }

        #endregion
    }
}

--- NEW FILE: PostBuildEvent.bat ---
@echo off
@echo ########### Setting environment variables
call "D:\Program Files\Microsoft Visual Studio .NET 2003\Common7\IDE\..\Tools\vsvars32.bat"
nmake
if errorlevel 1 goto CSharpReportError
goto CSharpEnd
:CSharpReportError
echo Project error: A tool returned an error code from the build event
exit 1
:CSharpEnd
--- NEW FILE: GDNRegularExpressions.cs ---
#region using

using System;
using System.Text.RegularExpressions;
using System.Xml;
using System.Xml.XPath;

#endregion

namespace Mvp.Xml.Exslt 
{
    /// <summary>
    /// This class implements additional functions in the http://gotdotnet.com/exslt/regular-expressions namespace.
    /// </summary>
    public class GDNRegularExpressions 
    {		    

        /// <summary>
        /// Implements the following function 
        ///		node-set tokenize(string, string)
        /// </summary>
        /// <param name="str"></param>
        /// <param name="regexp"></param>
        /// <returns>This function breaks the input string into a sequence of strings, 
        /// treating any substring that matches the regexp as a separator. 
        /// The separators themselves are not returned. 
        /// The matching strings are returned as a set of 'match' elements.</returns>
        /// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>
        public XPathNodeIterator tokenize(string str, string regexp)
        {
		
            RegexOptions options = RegexOptions.ECMAScript; 

            XmlDocument doc = new XmlDocument(); 
            doc.LoadXml("<matches/>"); 

            Regex regex = new Regex(regexp, options); 

            foreach(string match in regex.Split(str))
            {
			
                XmlElement elem = doc.CreateElement("match"); 
                elem.InnerText  = match; 
                doc.DocumentElement.AppendChild(elem); 
            }

            return doc.CreateNavigator().Select("//match"); 
        }

        /// <summary>
        /// Implements the following function 
        ///		node-set tokenize(string, string, string)
        /// </summary>
        /// <param name="str"></param>
        /// <param name="regexp"></param>		
        /// <param name="flags"></param>
        /// <returns>This function breaks the input string into a sequence of strings, 
        /// treating any substring that matches the regexp as a separator. 
        /// The separators themselves are not returned. 
        /// The matching strings are returned as a set of 'match' elements.</returns>
        /// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>
        public XPathNodeIterator tokenize(string str, string regexp, string flags)
        {
		
            RegexOptions options = RegexOptions.ECMAScript; 
			
            if(flags.IndexOf("m")!= -1)
            {
                options |= RegexOptions.Multiline;
            }

            if(flags.IndexOf("i")!= -1)
            {
                options |= RegexOptions.IgnoreCase;
            }

            XmlDocument doc = new XmlDocument(); 
            doc.LoadXml("<matches/>"); 

            Regex regex = new Regex(regexp, options); 

            foreach(string match in regex.Split(str))
            {
			
                XmlElement elem = doc.CreateElement("match"); 
                elem.InnerText  = match; 
                doc.DocumentElement.AppendChild(elem); 
            }

            return doc.CreateNavigator().Select("//match"); 
        }     
    }
}
--- NEW FILE: ExsltTransform.cs ---
#region using

using System;
using System.Xml.Xsl;
using System.Xml;
using System.Xml.XPath;
using System.IO; 
using System.Text;

#endregion

namespace Mvp.Xml.Exslt
{

	/// <summary>
	/// Enumeration used to indicate an EXSLT function namespace. 
	/// </summary>
	[Flags]
	public enum ExsltFunctionNamespace{ 
		None  = 0,
		Common     = 1, 
		DatesAndTimes  = 2, 
		Math = 4, 
		RegularExpressions = 8, 
		Sets = 16, 
		Strings = 32,
		GDNDatesAndTimes = 64,
		GDNSets = 128,
		GDNMath = 256,
		GDNRegularExpressions = 512,
		GDNStrings = 1024, 
		Random = 2048,
        GDNDynamic = 4096,
        AllExslt = Common | DatesAndTimes | Math | Random | RegularExpressions | Sets | Strings,            
		All = Common | DatesAndTimes | Math | Random | RegularExpressions | Sets | Strings | 
		    GDNDatesAndTimes | GDNSets | GDNMath | GDNRegularExpressions | GDNStrings | GDNDynamic
	}

	/// <summary>
	/// Transforms XML data using an XSLT stylesheet. Supports a number of EXSLT as 
	/// defined at http://www.exslt.org
	/// </summary>
	/// <remarks>
	/// XslTransform supports the XSLT 1.0 syntax. The XSLT stylesheet must use the 
	/// namespace http://www.w3.org/1999/XSL/Transform. Additional arguments can also be 
	/// added to the stylesheet using the XsltArgumentList class. 
	/// This class contains input parameters for the stylesheet and extension objects which can be called from the stylesheet.
	/// This class also recognizes functions from the following namespaces 
	/// * http://exslt.org/common
	/// * http://exslt.org/dates-and-times
	/// * http://exslt.org/math
	/// * http://exslt.org/random
	/// * http://exslt.org/regular-expressions
	/// * http://exslt.org/sets
	/// * http://exslt.org/strings
	/// * http://gotdotnet.com/exslt/dates-and-times
	/// * http://gotdotnet.com/exslt/math
	/// * http://gotdotnet.com/exslt/regular-expressions
	/// * http://gotdotnet.com/exslt/sets
	/// * http://gotdotnet.com/exslt/strings
	/// * http://gotdotnet.com/exslt/dynamic
	/// </remarks>
	public class ExsltTransform
	{

		#region Private Fields and Properties
    
    /// <summary>
    /// Sync object.
    /// </summary>
    private object sync = new object();

	/// <summary>
	/// The XslTransform object wrapped by this class. 
	/// </summary>
		private XslTransform xslTransform; 
		
		/// <summary>
		/// Bitwise enumeration used to specify which EXSLT functions should be accessible to 
		/// the ExsltTransform object. The default value is ExsltFunctionNamespace.All 
		/// </summary>
		private ExsltFunctionNamespace _supportedFunctions = ExsltFunctionNamespace.All; 

		/// <summary>
		/// Extension object which implements the functions in the http://exslt.org/common namespace
		/// </summary>
		private ExsltCommon exsltCommon = new ExsltCommon(); 

		/// <summary>
		/// Extension object which implements the functions in the http://exslt.org/math namespace
		/// </summary>
		private ExsltMath exsltMath = new ExsltMath(); 

		/// <summary>
		/// Extension object which implements the functions in the http://exslt.org/random namespace
		/// </summary>
		private ExsltRandom exsltRandom = new ExsltRandom(); 

		/// <summary>
		/// Extension object which implements the functions in the http://exslt.org/dates-and-times namespace
		/// </summary>
		private ExsltDatesAndTimes exsltDatesAndTimes = new ExsltDatesAndTimes(); 

		/// <summary>
		/// Extension object which implements the functions in the http://exslt.org/regular-expressions namespace
		/// </summary>
		private ExsltRegularExpressions exsltRegularExpressions = new ExsltRegularExpressions(); 

		/// <summary>
		/// Extension object which implements the functions in the http://exslt.org/strings namespace
		/// </summary>
		private ExsltStrings exsltStrings = new ExsltStrings(); 

		/// <summary>
		/// Extension object which implements the functions in the http://exslt.org/sets namespace
		/// </summary>
		private ExsltSets exsltSets = new ExsltSets(); 

        /// <summary>
        /// Extension object which implements the functions in the http://gotdotnet.com/exslt/dates-and-times namespace
        /// </summary>
        private GDNDatesAndTimes gdnDatesAndTimes = new GDNDatesAndTimes(); 
        
        /// <summary>
        /// Extension object which implements the functions in the http://gotdotnet.com/exslt/regular-expressions namespace
        /// </summary>
        private GDNRegularExpressions gdnRegularExpressions = new GDNRegularExpressions();
        
        /// <summary>
        /// Extension object which implements the functions in the http://gotdotnet.com/exslt/math namespace
        /// </summary>
        private GDNMath gdnMath = new GDNMath(); 
        
        /// <summary>
        /// Extension object which implements the functions in the http://gotdotnet.com/exslt/sets namespace
        /// </summary>
        private GDNSets gdnSets = new GDNSets();
                
        /// <summary>
        /// Extension object which implements the functions in the http://gotdotnet.com/exslt/strings namespace
        /// </summary>
        private GDNStrings gdnStrings = new GDNStrings();

        /// <summary>
        /// Extension object which implements the functions in the http://gotdotnet.com/exslt/dynamic namespace
        /// </summary>
        private GDNDynamic gdnDynamic = new GDNDynamic();
        
        /// <summary>
        /// Boolean flag used to specify whether multiple output is supported.
        /// </summary>
        private bool _multiOutput = false;

		#endregion

		#region Public Fields and Properties 
		
/// <summary>
/// Sets the XmlResolver used to resolve external resources when the 
/// Transform method is called.
/// </summary>
		public XmlResolver XmlResolver { set { this.xslTransform.XmlResolver = value; } }

/// <summary>
/// Bitwise enumeration used to specify which EXSLT functions should be accessible to 
/// the ExsltTransform object. The default value is ExsltFunctionNamespace.All 
/// </summary>
		public ExsltFunctionNamespace SupportedFunctions{		
			set { if (Enum.IsDefined(typeof(ExsltFunctionNamespace), value)) 
					  this._supportedFunctions = value; 
				} 
			get { return this._supportedFunctions; }
		}
		
        /// <summary>
        /// Boolean flag used to specify whether multiple output (via exsl:document) is 
        /// supported.
        /// Note: This property is ignored (hence multiple output is not supported) when
        /// transformation is done to XmlReader or XmlWriter (use overloaded method, 
        /// which transforms to MultiXmlTextWriter instead).
        /// Note: Because of some restrictions and slight overhead this feature is
        /// disabled by default. If you need multiple output support, set this property to
        /// true before the Transform() call.
        /// </summary>
		public bool MultiOutput {
		    get { return _multiOutput; }
		    set { _multiOutput = value; }
		}

		#endregion

		#region Constructors
/// <summary>
/// Constructor initializes class. 
/// </summary>
		public ExsltTransform(){
			this.xslTransform = new XslTransform(); 			
		}

		#endregion 

		#region Load() method Overloads  
		/// <summary> Loads the XSLT stylesheet contained in the IXPathNavigable</summary>
		public void Load(IXPathNavigable ixn){ this.xslTransform.Load(ixn); }


		/// <summary> Loads the XSLT stylesheet specified by a URL</summary>
		public void Load(string s){ this.xslTransform.Load(s); }

		/// <summary> Loads the XSLT stylesheet contained in the XmlReader</summary>
		public void Load(XmlReader reader){ this.xslTransform.Load(reader); }

		/// <summary> Loads the XSLT stylesheet contained in the XPathNavigator</summary>
		public void Load(XPathNavigator navigator){ this.xslTransform.Load(navigator); }

		/// <summary> Loads the XSLT stylesheet contained in the IXPathNavigable</summary>
		public void Load(IXPathNavigable ixn, XmlResolver resolver){ this.xslTransform.Load(ixn, resolver); }

		/// <summary> Loads the XSLT stylesheet specified by a URL</summary>
		public void Load(string s, XmlResolver resolver){ this.xslTransform.Load(s, resolver); }

		/// <summary> Loads the XSLT stylesheet contained in the XmlReader</summary>
		public void Load(XmlReader reader, XmlResolver resolver){ this.xslTransform.Load(reader, resolver); }

		/// <summary> Loads the XSLT stylesheet contained in the XPathNavigator</summary>
		public void Load(XPathNavigator navigator, XmlResolver resolver) {this.xslTransform.Load(navigator, resolver); }

		#endregion 

		#region Transform() method Overloads

		/// <summary> Transforms the XML data in the IXPathNavigable using the specified args and outputs the result to an XmlReader</summary>
		public XmlReader Transform(IXPathNavigable ixn, XsltArgumentList arglist)
		{  
			return this.xslTransform.Transform(ixn, this.AddExsltExtensionObjects(arglist));
		}

		/// <summary> Transforms the XML data in the input file and outputs the result to an output file</summary>
		public void Transform(string infile, string outfile)
		{ 
			// Use using so that the file is not held open after the call

			using (StreamWriter outStream = new StreamWriter(outfile)) 
			{
				if (_multiOutput)
					this.xslTransform.Transform(new XPathDocument(infile), this.AddExsltExtensionObjects(null),
						new MultiXmlTextWriter(outStream)); 
				else
					this.xslTransform.Transform(new XPathDocument(infile), this.AddExsltExtensionObjects(null), outStream);	    
			}
		}

		/// <summary> Transforms the XML data in the XPathNavigator using the specified args and outputs the result to an XmlReader</summary>
		public XmlReader Transform(XPathNavigator navigator, XsltArgumentList arglist)
		{
		    return this.xslTransform.Transform(navigator, this.AddExsltExtensionObjects(arglist)); 
		}

		/// <summary> Transforms the XML data in the IXPathNavigable using the specified args and outputs the result to a Stream</summary>
		public void Transform(IXPathNavigable ixn, XsltArgumentList arglist, Stream stream)
		{ 
		    if (_multiOutput)
		        this.xslTransform.Transform(ixn, this.AddExsltExtensionObjects(arglist), 
		            new MultiXmlTextWriter(stream, Encoding.UTF8)); 
		    else
		        this.xslTransform.Transform(ixn, this.AddExsltExtensionObjects(arglist), stream);
		}

		/// <summary> Transforms the XML data in the IXPathNavigable using the specified args and outputs the result to a TextWriter</summary>
		public void Transform(IXPathNavigable ixn, XsltArgumentList arglist, TextWriter writer)
		{ 
		    if (_multiOutput)
		        this.xslTransform.Transform(ixn, this.AddExsltExtensionObjects(arglist), 
		            new MultiXmlTextWriter(writer)); 
		    else
		        this.xslTransform.Transform(ixn, this.AddExsltExtensionObjects(arglist), writer);
		}

		/// <summary> Transforms the XML data in the IXPathNavigable using the specified args and outputs the result to an XmlWriter</summary>
		public void Transform(IXPathNavigable ixn, XsltArgumentList arglist, XmlWriter writer)
		{ 
		    this.xslTransform.Transform(ixn, this.AddExsltExtensionObjects(arglist), writer); 
		}
		
        /// <summary> Transforms the XML data in the IXPathNavigable using the specified args and outputs the result to an MultiXmlTextWriter</summary>
        public void Transform(IXPathNavigable ixn, XsltArgumentList arglist, MultiXmlTextWriter writer)
        { 
            this.xslTransform.Transform(ixn, this.AddExsltExtensionObjects(arglist), writer); 
        }

		/// <summary> Transforms the XML data in the XPathNavigator using the specified args and outputs the result to a Stream</summary>
		public void Transform(XPathNavigator navigator, XsltArgumentList arglist, Stream stream)
		{ 
		    if (_multiOutput)		         		    
		        this.xslTransform.Transform(navigator, this.AddExsltExtensionObjects(arglist), 
		            new MultiXmlTextWriter(stream, Encoding.UTF8));
		    else
		        this.xslTransform.Transform(navigator, this.AddExsltExtensionObjects(arglist), stream);
		}

		/// <summary> Transforms the XML data in the XPathNavigator using the specified args and outputs the result to a TextWriter</summary>
		public void Transform(XPathNavigator navigator, XsltArgumentList arglist, TextWriter writer)
		{ 
		    if (_multiOutput)
		        this.xslTransform.Transform(navigator, this.AddExsltExtensionObjects(arglist), 
		            new MultiXmlTextWriter(writer));
            else
                this.xslTransform.Transform(navigator, this.AddExsltExtensionObjects(arglist), writer);                		        
		}

		/// <summary> Transforms the XML data in the XPathNavigator using the specified args and outputs the result to an XmlWriter</summary>
		public void Transform(XPathNavigator navigator, XsltArgumentList arglist, XmlWriter writer)
		{ 
		    this.xslTransform.Transform(navigator, this.AddExsltExtensionObjects(arglist), writer); 
		}
		
        /// <summary> Transforms the XML data in the XPathNavigator using the specified args and outputs the result to an MultiXmlTextWriter</summary>
        public void Transform(XPathNavigator navigator, XsltArgumentList arglist, MultiXmlTextWriter writer)
        { 
            this.xslTransform.Transform(navigator, this.AddExsltExtensionObjects(arglist), writer); 
        }

		#endregion 

		#region Public Methods 

		#endregion 

		#region Private Methods 

		/// <summary>
		/// Adds the objects that implement the EXSLT extensions to the provided argument 
		/// list. The extension objects added depend on the value of the SupportedFunctions
		/// property.
		/// </summary>
		/// <param name="arglist">The argument list</param>
		/// <returns>An XsltArgumentList containing the contents of the list passed in 
		/// and objects that implement the EXSLT. </returns>
		/// <remarks>If null is passed in then a new XsltArgumentList is constructed. </remarks>
		private XsltArgumentList AddExsltExtensionObjects(XsltArgumentList list){
			if(list == null){
				list = new XsltArgumentList();
			}      
		
      lock (sync) 
      {
        //remove all our extension objects in case the XSLT argument list is being reused
        list.RemoveExtensionObject(ExsltNamespaces.Common); 
        list.RemoveExtensionObject(ExsltNamespaces.Math); 
        list.RemoveExtensionObject(ExsltNamespaces.Random); 
        list.RemoveExtensionObject(ExsltNamespaces.DatesAndTimes); 
        list.RemoveExtensionObject(ExsltNamespaces.RegularExpressions); 
        list.RemoveExtensionObject(ExsltNamespaces.Strings);
        list.RemoveExtensionObject(ExsltNamespaces.Sets); 
        list.RemoveExtensionObject(ExsltNamespaces.GDNDatesAndTimes);
        list.RemoveExtensionObject(ExsltNamespaces.GDNMath);
        list.RemoveExtensionObject(ExsltNamespaces.GDNRegularExpressions);
        list.RemoveExtensionObject(ExsltNamespaces.GDNSets);
        list.RemoveExtensionObject(ExsltNamespaces.GDNStrings);
        list.RemoveExtensionObject(ExsltNamespaces.GDNDynamic);
			            
        //add extension objects as specified by SupportedFunctions
        if((this.SupportedFunctions & ExsltFunctionNamespace.Common) > 0)
        { 
          list.AddExtensionObject(ExsltNamespaces.Common, this.exsltCommon); 
        }

        if((this.SupportedFunctions & ExsltFunctionNamespace.Math) > 0)
        { 
          list.AddExtensionObject(ExsltNamespaces.Math, this.exsltMath); 
        }

        if((this.SupportedFunctions & ExsltFunctionNamespace.Random) > 0)
        { 
          list.AddExtensionObject(ExsltNamespaces.Random, this.exsltRandom); 
        }

        if((this.SupportedFunctions & ExsltFunctionNamespace.DatesAndTimes) > 0)
        { 
          list.AddExtensionObject(ExsltNamespaces.DatesAndTimes, this.exsltDatesAndTimes); 
        }

        if((this.SupportedFunctions & ExsltFunctionNamespace.RegularExpressions) > 0)
        { 
          list.AddExtensionObject(ExsltNamespaces.RegularExpressions, this.exsltRegularExpressions); 
        }

        if((this.SupportedFunctions & ExsltFunctionNamespace.Strings) > 0)
        { 
          list.AddExtensionObject(ExsltNamespaces.Strings, this.exsltStrings); 
        }

        if((this.SupportedFunctions & ExsltFunctionNamespace.Sets) > 0)
        { 
          list.AddExtensionObject(ExsltNamespaces.Sets, this.exsltSets); 
        }
			
        if((this.SupportedFunctions & ExsltFunctionNamespace.GDNDatesAndTimes) > 0)
        { 
          list.AddExtensionObject(ExsltNamespaces.GDNDatesAndTimes, this.gdnDatesAndTimes); 
        }
            
        if((this.SupportedFunctions & ExsltFunctionNamespace.GDNMath) > 0)
        { 
          list.AddExtensionObject(ExsltNamespaces.GDNMath, this.gdnMath); 
        }
            
        if((this.SupportedFunctions & ExsltFunctionNamespace.GDNRegularExpressions) > 0)
        { 
          list.AddExtensionObject(ExsltNamespaces.GDNRegularExpressions, this.gdnRegularExpressions); 
        }
            
        if((this.SupportedFunctions & ExsltFunctionNamespace.GDNSets) > 0)
        { 
          list.AddExtensionObject(ExsltNamespaces.GDNSets, this.gdnSets); 
        }
            
        if((this.SupportedFunctions & ExsltFunctionNamespace.GDNStrings) > 0)
        { 
          list.AddExtensionObject(ExsltNamespaces.GDNStrings, this.gdnStrings); 
        }
        
        if((this.SupportedFunctions & ExsltFunctionNamespace.GDNDynamic) > 0)
        { 
          list.AddExtensionObject(ExsltNamespaces.GDNDynamic, this.gdnDynamic); 
        }
      }
			
			return list; 
		}

		#endregion

	}
}

--- NEW FILE: AssemblyInfo.cs ---
using System;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;


//
// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly: AssemblyTitle("Mvp.Xml.Exslt")]
[assembly: AssemblyDescription("MVP XML Library - EXSLT.NET Module")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]		

[assembly: ComVisible(false)]
[assembly: CLSCompliant(true)]

//
// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version 
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Revision and Build Numbers 
// by using the '*' as shown below:

[assembly: AssemblyVersion("1.3.*")]

//
// In order to sign your assembly you must specify a key to use. Refer to the 
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing. 
//
// Notes: 
//   (*) If no key is specified, the assembly is not signed.
//   (*) KeyName refers to a key that has been installed in the Crypto Service
//       Provider (CSP) on your machine. KeyFile refers to a file which contains
//       a key.
//   (*) If the KeyFile and the KeyName values are both specified, the 
//       following processing occurs:
//       (1) If the KeyName can be found in the CSP, that key is used.
//       (2) If the KeyName does not exist and the KeyFile does exist, the key 
//           in the KeyFile is installed into the CSP and used.
//   (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
//       When specifying the KeyFile, the location of the KeyFile should be
//       relative to the project output directory which is
//       %Project Directory%\obj\<configuration>. For example, if your KeyFile is
//       located in the project directory, you would specify the AssemblyKeyFile 
//       attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
//   (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
//       documentation for more information on this.
//
[assembly: AssemblyDelaySign(false)]
//Signed in custom build - see Makefile
//[assembly: AssemblyKeyFile("exslt.snk")]
[assembly: AssemblyKeyName("")]

--- NEW FILE: GDNMath.cs ---
#region using

using System;
using System.Xml;
using System.Xml.XPath;

#endregion

namespace Mvp.Xml.Exslt
{
    /// <summary>
    /// This class implements addditional functions in the http://gotdotnet.com/exslt/math namespace.
    /// </summary>
    public class GDNMath 
    {
        
        /// <summary>
        /// Implements the following function 
        ///    number avg(node-set)
        /// </summary>
        /// <param name="iterator"></param>
        /// <returns>The average of all the value of all the nodes in the 
        /// node set</returns>
        /// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>
        public double avg(XPathNodeIterator iterator)
        {

            double sum = 0; 
            int count = iterator.Count;

            if(count == 0)
            {
                return Double.NaN; 
            }

            try
            { 
                while(iterator.MoveNext())
                {
                    sum += XmlConvert.ToDouble(iterator.Current.Value);
                }
				
            }
            catch(FormatException)
            {
                return Double.NaN; 
            }			 

            return sum / count; 
        }
    }
}


--- NEW FILE: install.cmd ---
gacutil /if Mvp.Xml.Exslt.dll
--- NEW FILE: Exslt.csproj.user ---
<VisualStudioProject>
    <CSHARP LastOpenVersion = "7.10.3077" >
        <Build>
            <Settings ReferencePath = "" >
                <Config
                    Name = "Debug"
                    EnableASPDebugging = "false"
                    EnableASPXDebugging = "false"
                    EnableUnmanagedDebugging = "false"
                    EnableSQLServerDebugging = "false"
                    RemoteDebugEnabled = "false"
                    RemoteDebugMachine = ""
                    StartAction = "Project"
                    StartArguments = ""
                    StartPage = ""
                    StartProgram = ""
                    StartURL = ""
                    StartWorkingDirectory = ""
                    StartWithIE = "false"
                />
                <Config
                    Name = "Release"
                    EnableASPDebugging = "false"
                    EnableASPXDebugging = "false"
                    EnableUnmanagedDebugging = "false"
                    EnableSQLServerDebugging = "false"
                    RemoteDebugEnabled = "false"
                    RemoteDebugMachine = ""
                    StartAction = "Project"
                    StartArguments = ""
                    StartPage = ""
                    StartProgram = ""
                    StartURL = ""
                    StartWorkingDirectory = ""
                    StartWithIE = "false"
                />
            </Settings>
        </Build>
        <OtherProjectSettings
            CopyProjectDestinationFolder = ""
            CopyProjectUncPath = ""
            CopyProjectOption = "0"
            ProjectView = "ProjectFiles"
            ProjectTrust = "0"
        />
    </CSHARP>
</VisualStudioProject>


--- NEW FILE: .cvsignore ---
bin
obj
*.user
*.suo
*.dll
*.pdb
--- NEW FILE: index.html ---
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
    <head>
        <title>EXSLT.NET version 1.1</title>
        <meta content="Microsoft Visual Studio.NET 7.0" name="GENERATOR">
        <meta content="http://schemas.microsoft.com/intellisense/ie5" name="vs_targetSchema">
        <style type="text/css"> BODY { font-family:Verdana, Tahoma, Arial; font-size:10pt; }
        </style>
    </head>
    <body>
        <H2 align="center">EXSLT.NET version 1.1</H2>
        <H3>Contents</H3>
        <OL>
            <LI>
                <A href="#whatis">What Is EXSLT.NET</A>
            <LI>
                <A href="#new">What's New In This Version</A>
            <LI>
                <A href="#install">Installation</A>
            <LI>
                <A href="#build">Building</A>
            <LI>
                <A href="#usage">Usage</A>
            <LI>
                <A href="#funclist">Extension Functions and Elements</A>
            &nbsp;&nbsp;
            <LI>
                <A href="#multiout">Multiple Output</A>
            <LI>
                <A href="#credits">Credits And Legal Stuff</A>
            <LI>
                <A href="#refs">References</A></LI></OL>
        <H3><a name="whatis">1. What Is EXSLT.NET</a></H3>
        <P>EXSLT.NET library is community-developed implementation of the <A href="http://exslt.org">
                EXSLT</A> extensions to XSLT for the .NET platform. EXSLT.NET fully 
            implements the following EXSLT modules: <A href="http://exslt.org/date/index.html">Dates 
                and Times</A>, <A href="http://exslt.org/exsl/index.html">Common</A>, <A href="http://exslt.org/math/index.html">
                Math</A>, <A href="http://exslt.org/random/index.html">Random</A>, <A href="http://exslt.org/regexp/index.html">
                Regular Expressions</A>, <A href="http://exslt.org/set/index.html">Sets</A> 
            and <A href="http://exslt.org/str/index.html">Strings</A>. In addition 
            EXSLT.NET library provides proprietary set of useful extension functions. See 
            full list of supported extension functions and elements in "<A href="#funclist">Extension 
                Functions and Elements</A>" section. For more info about EXSLT and 
            EXSLT.NET see <A href="#refs">References</A>.
        </P>
        <H3><a name="new">2. What's New In This Version</a></H3>
        <UL>
            <LI>
                New EXSLT extension functions has been implemented: <A href="http://exslt.org/str/functions/encode-uri/index.html">
                    <FONT face="Courier New">str:encode-uri()</FONT></A>, <A href="http://exslt.org/str/functions/decode-uri/index.html">
                    <FONT face="Courier New">str:decode-uri()</FONT></A>, <A href="http://exslt.org/random/functions/random-sequence/index.html">
                    <FONT face="Courier New">random:random-sequence()</FONT></A>.
            <LI>
                New EXSLT.NET extension functions has been implemented: <FONT face="Courier New"><A href="doc/GDNDynamic-evaluate.xml">
                        dyn2:evaluate()</A></FONT>, which allows to evaluate a string as an 
                XPath expression, <FONT face="Courier New"><A href="doc/GDNDatesAndTimes-day-name.xml">date2:day-name()</A></FONT>,
                <FONT face="Courier New"><A href="doc/GDNDatesAndTimes-day-abbreviation.xml">date2:day-abbreviation()</A></FONT>,
                <FONT face="Courier New"><A href="doc/GDNDatesAndTimes-month-name.xml">date2:month-name()</A></FONT>
                and&nbsp;<FONT face="Courier New"><A href="doc/GDNDatesAndTimes-month-abbreviation.xml">date2:month-abbreviation()</A></FONT>
            - these functions are culture-aware versions of the appropriate EXSLT 
            functions.
            <LI>
            Support for time zone in date-time functions has&nbsp; been implemented.
            <LI>
                Multithreading issue with <FONT face="Courier New">ExsltTransform</FONT> class 
                has been fixed. Now <FONT face="Courier New">ExsltTransform</FONT> class is 
                thread-safe for <FONT face="Courier New">Transform()</FONT> method 
                calls&nbsp;just like the&nbsp; <FONT face="Courier New">System.Xml.Xsl.XslTransform</FONT>
            class.
            <LI>
                Lots of minor bugs has been fixed. See EXSLT.NET <A href="http://www.gotdotnet.com/workspaces/bugtracker/home.aspx?id=201eb290-5bf0-4452-9bf7-d21d39268f36">
                    bug tracker</A>
            for more info.
            <LI>
            We switched to Visual Studio .NET 2003, so building of the project has been 
            greatly simplified.
            <LI>
                Complete suite of NUnit tests for each extension function has been implemented 
                (<FONT face="Courier New">ExsltTest</FONT> project).</LI></UL>
        <H3>3<a name="install">. Installation</a></H3>
        <P>EXSLT.NET is designed as a component for .NET Framework and actually doesn't 
            require any installation. You can use <FONT face="Courie...
 
[truncated message content]

[mvp-xml-cvs] EXSLT/v1/src/Exslt/doc Functions.htm,NONE,1.1 Functions.xml,NONE,1.1 Functions.xslt,NONE,1.1 GDNDatesAndTimes-avg.xml,NONE,1.1 GDNDatesAndTimes-day-abbreviation.xml,NONE,1.1 GDNDatesAndTimes-day-name.xml,NONE,1.1 GDNDatesAndTimes-max.xml,NONE,1.1 GDNDatesAndTimes-min.xml,NONE,1.1 GDNDatesAndTimes-month-abbreviation.xml,NONE,1.1 GDNDatesAndTimes-month-name.xml,NONE,1.1 GDNDynamic-evaluate.xml,NONE,1.1 GDNFunctions.xsl,NONE,1.1 GDNMath-avg.xml,NONE,1.1 GDNRegularExpressions-tokenize.xml,NONE,1.1 GDNSets-subset.xml,NONE,1.1 GDNStrings-lowercase.xml,NONE,1.1 GDNStrings-uppercase.xml,NONE,1.1 buildFuncList.cmd,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/src/Exslt/doc
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/src/Exslt/doc

Added Files:
	Functions.htm Functions.xml Functions.xslt 
	GDNDatesAndTimes-avg.xml GDNDatesAndTimes-day-abbreviation.xml 
	GDNDatesAndTimes-day-name.xml GDNDatesAndTimes-max.xml 
	GDNDatesAndTimes-min.xml 
	GDNDatesAndTimes-month-abbreviation.xml 
	GDNDatesAndTimes-month-name.xml GDNDynamic-evaluate.xml 
	GDNFunctions.xsl GDNMath-avg.xml 
	GDNRegularExpressions-tokenize.xml GDNSets-subset.xml 
	GDNStrings-lowercase.xml GDNStrings-uppercase.xml 
	buildFuncList.cmd 
Log Message:


--- NEW FILE: GDNDatesAndTimes-month-abbreviation.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="month-abbreviation" namespace="http://gotdotnet.com/exslt/dates-and-times" prefix="date2">
    <syntax>
        <return>string</return>
        <params>
            <param optional="yes">string</param>
            <param>string</param>
        </params>
    </syntax>
    <description>
        <p>The <tt>date2:month-abbreviation</tt> function is I18N extension of 
        the <a href="http://exslt.org/date/functions/month-abbreviation/index.html"><tt>date:month-abbreviation</tt></a> function.<br/>        
        Second non-optional argument is valid according to RFC 1766 culture name 
        (supported by <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationCultureInfoClassTopic.asp">System.Globalization.CultureInfo</a> class 
        of .NET framework) in "&lt;languagecode2&gt;-&lt;country/regioncode2&gt;" format, e.g. 
        "en-US" or "he-IL".
        </p>
    </description>
    <sample>
        <source><![CDATA[
<root>
    <date>2004-09-01</date>
</root>]]></source>
        <stylesheet><![CDATA[
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:date2="http://gotdotnet.com/exslt/dates-and-times" exclude-result-prefixes="date2">   
  <xsl:template match="root">
Month name abbreviation in Turkish: <xsl:value-of select="date2:month-abbreviation(date, 'tr-TR')"/>
  </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result>Month name abbreviation in Turkish: Eyl</result>
    </sample>
</function>


--- NEW FILE: Functions.xml ---
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="Functions.xslt"?>
<modules version="1.2">
    <module namespace="http://exslt.org/dates-and-times" prefix="date" name="Dates and Times" homepage="http://exslt.org/date/index.html" is-exslt-module="yes">
        <function name="format-date" alias="formatDate" descriptionURL="http://exslt.org/date/functions/format-date/index.html" supported="yes"/>
        <function name="parse-date" alias="parseDate" descriptionURL="http://exslt.org/date/functions/parse-date/index.html" supported="yes"/>
        <function name="date-time" alias="dateTime" descriptionURL="http://exslt.org/date/functions/date-time/index.html" supported="yes"/>
        <function name="date" descriptionURL="http://exslt.org/date/functions/date/index.html" supported="yes"/>
        <function name="time" descriptionURL="http://exslt.org/date/functions/time/index.html" supported="yes"/>
        <function name="year" descriptionURL="http://exslt.org/date/functions/year/index.html" supported="yes"/>
        <function name="leap-year" alias="leapYear" descriptionURL="http://exslt.org/date/functions/leap-year/index.html" supported="yes"/>
        <function name="month-in-year" alias="monthInYear" descriptionURL="http://exslt.org/date/functions/month-in-year/index.html" supported="yes"/>
        <function name="month-name" alias="monthName" descriptionURL="http://exslt.org/date/functions/month-name/index.html" supported="yes"/>
        <function name="month-abbreviation" alias="monthAbbreviation" descriptionURL="http://exslt.org/date/functions/month-abbreviation/index.html" supported="yes"/>
        <function name="week-in-year" alias="weekInYear" descriptionURL="http://exslt.org/date/functions/week-in-year/index.html" supported="yes"/>
        <function name="week-in-month" alias="weekInMonth" descriptionURL="http://exslt.org/date/functions/week-in-month/index.html" supported="yes"/>
        <function name="day-in-year" alias="dayInYear" descriptionURL="http://exslt.org/date/functions/day-in-year/index.html" supported="yes"/>
        <function name="day-in-month" alias="dayInMonth" descriptionURL="http://exslt.org/date/functions/day-in-month/index.html" supported="yes"/>
        <function name="day-of-week-in-month" alias="dayOfWeekInMonth" descriptionURL="http://exslt.org/date/functions/day-of-week-in-month/index.html" supported="yes"/>
        <function name="day-in-week" alias="dayInWeek" descriptionURL="http://exslt.org/date/functions/day-in-week/index.html" supported="yes"/>
        <function name="day-name" alias="dayName" descriptionURL="http://exslt.org/date/functions/day-name/index.html" supported="yes"/>
        <function name="day-abbreviation" alias="dayAbbreviation" descriptionURL="http://exslt.org/date/functions/day-abbreviation/index.html" supported="yes"/>
        <function name="hour-in-day" alias="hourInDay" descriptionURL="http://exslt.org/date/functions/hour-in-day/index.html" supported="yes"/>
        <function name="minute-in-hour" alias="minuteInHour" descriptionURL="http://exslt.org/date/functions/minute-in-hour/index.html" supported="yes"/>
        <function name="second-in-minute" alias="secondInMinute" descriptionURL="http://exslt.org/date/functions/second-in-minute/index.html" supported="yes"/>
        <function name="difference" descriptionURL="http://exslt.org/date/functions/difference/index.html" supported="yes"/>
        <function name="add" descriptionURL="http://exslt.org/date/functions/add/index.html" supported="yes"/>
        <function name="add-duration" alias="addDuration" descriptionURL="http://exslt.org/date/functions/add-duration/index.html" supported="yes"/>
        <function name="sum" descriptionURL="http://exslt.org/date/functions/sum/index.html" supported="yes"/>
        <function name="seconds" descriptionURL="http://exslt.org/date/functions/seconds/index.html" supported="yes"/>
        <function name="duration" descriptionURL="http://exslt.org/date/functions/duration/index.html" supported="yes"/>
    </module>
    <module namespace="http://exslt.org/common" prefix="exsl" name="Common" homepage="http://exslt.org/exsl/index.html" is-exslt-module="yes">
        <function name="node-set" alias="nodeSet" descriptionURL="http://exslt.org/exsl/functions/node-set/index.html" supported="yes"/>
        <function name="object-type" alias="objectType" descriptionURL="http://exslt.org/exsl/functions/object-type/index.html" supported="yes"/>
    </module>
    <module namespace="http://exslt.org/math" prefix="math" name="Math" homepage="http://exslt.org/math/index.html" is-exslt-module="yes">
        <function name="min" descriptionURL="http://exslt.org/math/functions/min/index.html" supported="yes"/>
        <function name="max" descriptionURL="http://exslt.org/math/functions/max/index.html" supported="yes"/>
        <function name="highest" descriptionURL="http://exslt.org/math/functions/highest/index.html" supported="yes"/>
        <function name="lowest" descriptionURL="http://exslt.org/math/functions/lowest/index.html" supported="yes"/>
        <function name="abs" descriptionURL="http://exslt.org/math/functions/abs/index.html" supported="yes"/>
        <function name="sqrt" descriptionURL="http://exslt.org/math/functions/sqrt/index.html" supported="yes"/>
        <function name="power" descriptionURL="http://exslt.org/math/functions/power/index.html" supported="yes"/>
        <function name="constant" descriptionURL="http://exslt.org/math/functions/constant/index.html" supported="yes"/>
        <function name="log" descriptionURL="http://exslt.org/math/functions/log/index.html" supported="yes"/>
        <function name="random" descriptionURL="http://exslt.org/math/functions/random/index.html" supported="yes"/>
        <function name="sin" descriptionURL="http://exslt.org/math/functions/sin/index.html" supported="yes"/>
        <function name="cos" descriptionURL="http://exslt.org/math/functions/cos/index.html" supported="yes"/>
        <function name="tan" descriptionURL="http://exslt.org/math/functions/tan/index.html" supported="yes"/>
        <function name="asin" descriptionURL="http://exslt.org/math/functions/asin/index.html" supported="yes"/>
        <function name="acos" descriptionURL="http://exslt.org/math/functions/acos/index.html" supported="yes"/>
        <function name="atan" descriptionURL="http://exslt.org/math/functions/atan/index.html" supported="yes"/>
        <function name="atan2" descriptionURL="http://exslt.org/math/functions/atan2/index.html" supported="yes"/>
        <function name="exp" descriptionURL="http://exslt.org/math/functions/exp/index.html" supported="yes"/>
    </module>
    <module namespace="http://exslt.org/random" prefix="random" name="Random" homepage="http://exslt.org/random/index.html" is-exslt-module="yes">
		<function name="random-sequence" alias="randomSequence" descriptionURL="http://exslt.org/random/functions/random-sequence/index.html" supported="yes"/>
    </module>
    <module namespace="http://exslt.org/regular-expressions" prefix="regexp" name="Regular Expressions" homepage="http://exslt.org/regexp/index.html" is-exslt-module="yes">
        <function name="test" descriptionURL="http://exslt.org/regexp/functions/test/index.html" supported="yes"/>
        <function name="match" descriptionURL="http://exslt.org/regexp/functions/match/index.html" supported="yes"/>
        <function name="replace" descriptionURL="http://exslt.org/regexp/functions/replace/index.html" supported="yes"/>
    </module>
    <module namespace="http://exslt.org/sets" prefix="set" name="Sets" homepage="http://exslt.org/set/index.html" is-exslt-module="yes">
        <function name="difference" descriptionURL="http://exslt.org/set/functions/difference/index.html" supported="yes"/>
        <function name="intersection" descriptionURL="http://exslt.org/set/functions/intersection/index.html" supported="yes"/>
        <function name="distinct" descriptionURL="http://exslt.org/set/functions/distinct/index.html" supported="yes"/>
        <function name="has-same-node" descriptionURL="http://exslt.org/set/functions/has-same-node/index.html" supported="yes"/>
        <function name="leading" descriptionURL="http://exslt.org/set/functions/leading/index.html" supported="yes"/>
        <function name="trailing" descriptionURL="http://exslt.org/set/functions/trailing/index.html" supported="yes"/>
    </module>
    <module namespace="http://exslt.org/strings" prefix="str" name="Strings" homepage="http://exslt.org/str/index.html" is-exslt-module="yes">
        <function name="tokenize" descriptionURL="http://exslt.org/str/functions/tokenize/index.html" supported="yes"/>
        <function name="replace" descriptionURL="http://exslt.org/str/functions/replace/index.html" supported="yes"/>
        <function name="padding" descriptionURL="http://exslt.org/str/functions/padding/index.html" supported="yes"/>
        <function name="align" descriptionURL="http://exslt.org/str/functions/align/index.html" supported="yes"/>
        <function name="encode-uri" descriptionURL="http://exslt.org/str/functions/encode-uri/index.html" supported="yes"/>
        <function name="decode-uri" descriptionURL="http://exslt.org/str/functions/decode-uri/index.html" supported="yes"/>
        <function name="concat" descriptionURL="http://exslt.org/str/functions/concat/index.html" supported="yes"/>
        <function name="split" descriptionURL="http://exslt.org/str/functions/split/index.html" supported="yes"/>
    </module>
    <!-- Additional EXSLT.NET functions -->
    <module namespace="http://gotdotnet.com/exslt/dates-and-times" prefix="date2" name="GotDotNet Dates and Times" is-exslt-module="no">
        <function name="avg" descriptionURL="GDNDatesAndTimes-avg.xml" supported="yes"/>
        <function name="min" descriptionURL="GDNDatesAndTimes-min.xml" supported="yes"/>
        <function name="max" descriptionURL="GDNDatesAndTimes-max.xml" supported="yes"/>
        <function name="day-name" alias="dayName" descriptionURL="GDNDatesAndTimes-day-name.xml" supported="yes"/>
        <function name="day-abbreviation" alias="dayAbbreviation" descriptionURL="GDNDatesAndTimes-day-abbreviation.xml" supported="yes"/>        
        <function name="month-name" alias="monthName" descriptionURL="GDNDatesAndTimes-month-name.xml" supported="yes"/>
        <function name="month-abbreviation" alias="monthAbbreviation" descriptionURL="GDNDatesAndTimes-month-abbreviation.xml" supported="yes"/>
    </module>
    <module namespace="http://gotdotnet.com/exslt/math" prefix="math2" name="GotDotNet Math" is-exslt-module="no">
        <function name="avg" descriptionURL="GDNMath-avg.xml" supported="yes"/>
    </module>
    <module namespace="http://gotdotnet.com/exslt/regular-expressions" prefix="regexp2" name="GotDotNet Regular Expressions" is-exslt-module="no">
        <function name="tokenize" descriptionURL="GDNRegularExpressions-tokenize.xml" supported="yes"/>
    </module>
    <module namespace="http://gotdotnet.com/exslt/sets" prefix="set2" name="GotDotNet Sets" is-exslt-module="no">
        <function name="subset" descriptionURL="GDNSets-subset.xml" supported="yes"/>
    </module>
     <module namespace="http://gotdotnet.com/exslt/strings" prefix="str2" name="GotDotNet Strings" is-exslt-module="no">
        <function name="uppercase" descriptionURL="GDNStrings-uppercase.xml" supported="yes"/>
        <function name="lowercase" descriptionURL="GDNStrings-lowercase.xml" supported="yes"/>
    </module>
    <module namespace="http://gotdotnet.com/exslt/dynamic" prefix="dyn2" name="GotDotNet Dynamic" is-exslt-module="no">
        <function name="evaluate" descriptionURL="GDNDynamic-evaluate.xml" supported="yes"/>
    </module>
</modules>

--- NEW FILE: GDNDatesAndTimes-min.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="min" namespace="http://gotdotnet.com/exslt/dates-and-times" prefix="date2">
    <syntax>
        <return>string</return>
        <params>
            <param>node-set</param>
        </params>
    </syntax>
    <description>
        <p>The <tt>date2:avg</tt> function returns minimum duration.<br/> 
       String values of nodes in the argument nodeset must be in the format defined for xs:duration in [<a href="http://www.w3.org/TR/xmlschema-2/#duration">3.2.6 duration</a>] of [<a href="http://www.w3.org/TR/xmlschema-2/">XML Schema Part 2: Datatypes</a>].</p>
        <p>If the argument is empty nodeset or string value of any node in the nodeset is not in correct format, empty string is returned.</p>
        <p>The return value is a string in the format defined for xs:duration in [<a href="http://www.w3.org/TR/xmlschema-2/#duration">3.2.6 duration</a>] of [<a href="http://www.w3.org/TR/xmlschema-2/">XML Schema Part 2: Datatypes</a>].</p>
    </description>
    <sample>
        <source><![CDATA[
<root>
    <timespan>P1M</timespan>
    <timespan>P3M</timespan>
</root>]]></source>
        <stylesheet><![CDATA[
<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:date2="http://gotdotnet.com/exslt/dates-and-times">
    <xsl:template match="/">
Minimum time interval is 
<xsl:value-of select="date2:min(root/timespan)"/>.
    </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result>Minimum time interval is P30D.</result>
    </sample>
</function>

--- NEW FILE: GDNDynamic-evaluate.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="evaluate" namespace="http://gotdotnet.com/exslt/dynamic" prefix="dyn2">
    <syntax>
        <return>object</return>
        <params>
            <param>node-set</param>
            <param>string</param>
            <param optional="yes">string</param>
        </params>        
    </syntax>
    <description>
        <p>The <tt>dyn2:evaluate</tt> function evaluates a string as an XPath 
        expression and returns the resulting value, which might be a boolean, 
        number, string, node set, result tree fragment or external object.</p>
        <p>First node-set argument provides a context node (the first node 
        in the passed node-set), such that 
        selection paths are evaluated relative to it. Second string argument 
        is the XPath expression to be evaluated. Third optional string argument
        provides namespace bindings to be used to resolve namespace prefixes in 
        the XPath expression. Namespaces are defined in the XML style, as a 
        space separated list of namespace declaration attributes.</p>                
        <p>All namespace prefixes that are in scope for the context node (or its 
        parent node if the context node isn't element node) can be referenced in the 
        evaluated XPath expression. Note though that relying on namespace prefixes 
        defined in the source XML is very unreliable. We encourage users to define 
        namespace bindings explicitly in the third argument instead.</p>
        <p>If the node-set passed as first argument is empty (no context node) or 
        the expression string passed as the second argument is an invalid 
        XPath expression (including an empty string), this function returns an 
        empty string. Malformed namespace declarations in the third argument are 
        ignored.</p>
        <p>Note that this function is more limited than EXSLT's 
        <a href="http://exslt.org/dyn/functions/evaluate/index.html">dyn:evaluate()</a> 
        function. More formally:
        <ul>
            <li>No context position and context size information is available.</li>
            <li>No variable bindings - this function is unable to evaluate XPath 
            expressions, which contain variable references!</li>
            <li>No custom extension functions - only core XPath functions and
            all extension functions, supported by EXSLT.NET are available.</li>
            <li>No current node, so the expression cannot contain the 
            <tt>current()</tt> function calls.</li>
            <li>No key definition information available, so the expression cannot 
            contain the <tt>key()</tt> function calls.</li>
            <li>No custom decimal format definitions are avilable, so the expression 
            cannot contain the <tt>fomat-number()</tt> function calls that refer to
            a <tt>&lt;xsl:decimal-format></tt> definition.</li>
        </ul>
        </p>
        <p> You should only use this function if the expression must be constructed 
        dynamically - otherwise it is much more efficient to use the expression 
        literally. For expressions that simply give an element or attribute's 
        name (to select a child element or attribute), it is more efficient to 
        use an expression in the style:<br/>
        <code>*[name() = $expression]</code>
        </p>        
    </description>
    <sample>
        <source><![CDATA[<data xmlns:o="http://orders.com">
  <orders>
    <order id="o234">T-Shirt</order>
    <order id="o12">Polo Shirt</order>
    <order id="o332">Shoes</order>
  </orders>
  <orders xmlns="http://orders.com">
    <order id="o11">Foo</order>
    <order id="o22">Bar</order>
    <order id="o44">Baz</order>
  </orders>
  <path>/data/orders/order[@id='o12']</path>
  <path2>orders/order[@id='o12']</path2>  
  <path7>foo:orders/foo:order[@id='o11']</path7>
</data>]]></source>
        <stylesheet><![CDATA[<?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:dyn2="http://gotdotnet.com/exslt/dynamic" exclude-result-prefixes="dyn2">
    <xsl:output indent="yes" omit-xml-declaration="yes"/>
    <xsl:template match="data">
        <out>
            <test1>                
                <xsl:value-of select="dyn2:evaluate(., concat('2', '+', '2'))"/>
            </test1>
            <test2>                
                <xsl:copy-of select="dyn2:evaluate(., /data/path)"/>
            </test2>
            <test3>                
                <xsl:value-of select="dyn2:evaluate(., /data/path)/@id"/>
            </test3>
            <test4>                
                <xsl:copy-of select="dyn2:evaluate(., /data/path2)"/>
            </test4>                                                 
            <test5>                
                <xsl:copy-of select="dyn2:evaluate(., 'o:orders/o:order')"/>
            </test5>            
            <test6>
                <xsl:variable name="namespaces">xmlns:foo="http://orders.com" xmlns:bar='http://bar.com/'</xsl:variable>                                
                <xsl:copy-of select="dyn2:evaluate(., /data/path7, $namespaces)"/>
            </test6>                                            
        </out>
    </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result><![CDATA[<out>
  <test1>4</test1>
  <test2>
    <order id="o12" xmlns:o="http://orders.com">Polo Shirt</order>
  </test2>
  <test3>o12</test3>
  <test4>
    <order id="o12" xmlns:o="http://orders.com">Polo Shirt</order>
  </test4>
  <test5>
    <order id="o11" xmlns:o="http://orders.com" xmlns="http://orders.com">Foo</order>
    <order id="o22" xmlns:o="http://orders.com" xmlns="http://orders.com">Bar</order>
    <order id="o44" xmlns:o="http://orders.com" xmlns="http://orders.com">Baz</order>
  </test5>
  <test6>
    <order id="o11" xmlns:o="http://orders.com" xmlns="http://orders.com">Foo</order>
  </test6>
</out>]]></result>
    </sample>
</function>

--- NEW FILE: GDNStrings-uppercase.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="uppercase" namespace="http://gotdotnet.com/exslt/strings" prefix="str2">
    <syntax>
        <return>string</return>
        <params>
            <param>string</param>
        </params>
    </syntax>
    <description>
        <p>This function returns a copy of argument string in uppercase, using the casing rules of the current culture.</p>
    </description>
    <sample>
        <source><![CDATA[<input>The Quick Brown Fox Jumps Over a Lazy Dog.</input>]]></source>
        <stylesheet><![CDATA[<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:str2="http://gotdotnet.com/exslt/strings" 
extension-element-prefixes="str2">
    <xsl:template match="/">
        <out><xsl:value-of select="str2:uppercase(input)"/></out>
    </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result><![CDATA[<out>THE QUICK BROWN FOX JUMPS OVER A LAZY DOG.</out>]]></result>
    </sample>
</function>


--- NEW FILE: GDNStrings-lowercase.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="lowercase" namespace="http://gotdotnet.com/exslt/strings" prefix="str2">
    <syntax>
        <return>string</return>
        <params>
            <param>string</param>
        </params>
    </syntax>
    <description>
        <p>This function returns a copy of argument string in lowercase, using the casing rules of the current culture.</p>
    </description>
    <sample>
        <source><![CDATA[<input>The Quick Brown Fox Jumps Over a Lazy Dog.</input>]]></source>
        <stylesheet><![CDATA[<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:str2="http://gotdotnet.com/exslt/strings" 
extension-element-prefixes="str2">
    <xsl:template match="/">
        <out><xsl:value-of select="str2:lowercase(input)"/></out>
    </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result><![CDATA[<out>the quick brown fox jumps over a lazy dog.</out>]]></result>
    </sample>
</function>

--- NEW FILE: GDNDatesAndTimes-max.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="max" namespace="http://gotdotnet.com/exslt/dates-and-times" prefix="date2">
    <syntax>
        <return>string</return>
        <params>
            <param>node-set</param>
        </params>
    </syntax>
    <description>
        <p>The <tt>date2:avg</tt> function returns maximum duration.<br/> 
       String values of nodes in the argument nodeset must be in the format defined for xs:duration in [<a href="http://www.w3.org/TR/xmlschema-2/#duration">3.2.6 duration</a>] of [<a href="http://www.w3.org/TR/xmlschema-2/">XML Schema Part 2: Datatypes</a>].</p>
        <p>If the argument is empty nodeset or string value of any node in the nodeset is not in correct format, empty string is returned.</p>
        <p>The return value is a string in the format defined for xs:duration in [<a href="http://www.w3.org/TR/xmlschema-2/#duration">3.2.6 duration</a>] of [<a href="http://www.w3.org/TR/xmlschema-2/">XML Schema Part 2: Datatypes</a>].</p>
    </description>
    <sample>
        <source><![CDATA[
<root>
    <timespan>P1M</timespan>
    <timespan>P3M</timespan>
</root>]]></source>
        <stylesheet><![CDATA[
<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:date2="http://gotdotnet.com/exslt/dates-and-times">
    <xsl:template match="/">
Maximum time interval is 
<xsl:value-of select="date2:max(root/timespan)"/>.
    </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result>Maximum time interval is P90D.</result>
    </sample>
</function>

--- NEW FILE: GDNDatesAndTimes-month-name.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="month-name" namespace="http://gotdotnet.com/exslt/dates-and-times" prefix="date2">
    <syntax>
        <return>string</return>
        <params>
            <param optional="yes">string</param>
            <param>string</param>
        </params>
    </syntax>
    <description>
        <p>The <tt>date2:month-name</tt> function is I18N extension of 
        the <a href="http://exslt.org/date/functions/month-name/index.html"><tt>date:month-name</tt></a> function.<br/>        
        Second non-optional argument is valid according to RFC 1766 culture name 
        (supported by <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationCultureInfoClassTopic.asp">System.Globalization.CultureInfo</a> class 
        of .NET framework) in "&lt;languagecode2&gt;-&lt;country/regioncode2&gt;" format, e.g. 
        "en-US" or "he-IL".
        </p>
    </description>
    <sample>
        <source><![CDATA[
<root>
    <date>2004-09-01</date>
</root>]]></source>
        <stylesheet><![CDATA[
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:date2="http://gotdotnet.com/exslt/dates-and-times" exclude-result-prefixes="date2">   
  <xsl:template match="root">
Month name in Italian: <xsl:value-of select="date2:month-name(date, 'it-IT')"/>
  </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result>Month name in Italian: settembre</result>
    </sample>
</function>


--- NEW FILE: Functions.xslt ---
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:exslt="http://exslt.org/documentation" exclude-result-prefixes="exslt">
    <xsl:output indent="yes" encoding="ISO8859-1"/>
<!--    <xsl:template match="modules">
        <modules>
            <xsl:for-each select="module">
                <module namespace="{@namespace}">
                    <xsl:variable name="doc" select="document(@url)/*"/>
                    <xsl:variable name="prefix" select="$doc/@prefix"/>
                    <xsl:attribute name="prefix"><xsl:value-of select="$doc/@prefix"/></xsl:attribute>
                    <xsl:attribute name="name"><xsl:value-of select="$doc/exslt:name"/></xsl:attribute>
                    <xsl:attribute name="homepage"><xsl:value-of select="concat('http://exslt.org/', $prefix, '/index.html')"/></xsl:attribute>
                    <xsl:for-each select="$doc/exslt:functions/exslt:function">
                        <function name="{@name}" descriptionURL="{concat('http://exslt.org/', $prefix, '/functions/', @name, '/index.html')}" supported="yes"/>
                    </xsl:for-each>
                </module>
            </xsl:for-each>
        </modules>
    </xsl:template> -->
    <xsl:template match="/">
        <html>
            <head>
                <title>EXSLTNET 
                <xsl:value-of select="modules/@version"/> Function List</title>
                <style type="text/css">
                    body { font-family: Verdana, Arial, helvetica;}
                    .module-table {
                        width: 100%;
                    }                    
                </style>
            </head>
            <body>
                <h2>EXSLT.NET <xsl:value-of select="modules/@version"/> Function List</h2>
                <hr/>
                <div>EXSLT Modules:</div>
                <ol>                                
                    <xsl:apply-templates select="modules/module[@is-exslt-module='yes']" mode="toc"/>
                </ol>
                <div>Additional modules:</div>
                <ol>                                
                    <xsl:apply-templates select="modules/module[@is-exslt-module='no']" mode="toc"/>
                </ol>
                <hr/>
                <xsl:apply-templates select="modules/module"/>
            </body>
        </html>                
    </xsl:template>
    <xsl:template match="module" mode="toc">
        <li>
            <a href="#{@name}"><xsl:value-of select="@name"/></a>
        </li>       
    </xsl:template>
    <xsl:template match="module">        
        <p>
        <a name="{@name}">
        <div class="module-name"><b>Module:</b>&#xA0;<xsl:value-of select="@name"/></div></a>        
        <div class="module-ns"><b>Namespace:</b>&#xA0;<xsl:value-of select="@namespace"/></div>
        <xsl:if test="@homepage">
            <div class="module-homepage"><b>Homepage:</b>&#xA0;<a href="{@homepage}"><xsl:value-of select="@homepage"/></a></div>
        </xsl:if>
        <xsl:if test="@is-exslt-module='no'">
            <div class="note"><b>Note:</b> These functions are not part of EXSLT.</div>
        </xsl:if>
        <table border="1" class="module-table">
            <tr>
                <th>Function name</th>
                <th>Alias</th>
                <th>Supported</th>               
            </tr>
            <xsl:for-each select="function">
                <tr>
                    <td>
                    <xsl:choose>
                        <xsl:when test="@descriptionURL">
                            <a href="{@descriptionURL}"><xsl:value-of select="concat(../@prefix, ':', @name)"/></a>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:value-of select="concat(../@prefix, ':', @name)"/>
                        </xsl:otherwise>
                    </xsl:choose>
                    </td>
                    <td align="center">
                        <xsl:choose>
                            <xsl:when test="@alias">
                                <xsl:value-of select="@alias"/>
                            </xsl:when>
                            <xsl:otherwise>-</xsl:otherwise>
                        </xsl:choose>
                    </td>
                    <td align="center">
                    <xsl:attribute name="style">
                        <xsl:choose>
                            <xsl:when test="@supported='yes'">color:green;</xsl:when>
                            <xsl:otherwise>color:red;</xsl:otherwise>
                        </xsl:choose>
                    </xsl:attribute>
                    <xsl:value-of select="@supported"/></td>
                </tr>
            </xsl:for-each>
        </table>
        </p>
        <hr/>
    </xsl:template>
</xsl:stylesheet>

--- NEW FILE: GDNDatesAndTimes-avg.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="avg" namespace="http://gotdotnet.com/exslt/dates-and-times" prefix="date2">
    <syntax>
        <return>string</return>
        <params>
            <param>node-set</param>
        </params>
    </syntax>
    <description>
        <p>The <tt>date2:avg</tt> function returns average duration.<br/> 
       String values of nodes in the argument nodeset must be in the format defined for xs:duration in [<a href="http://www.w3.org/TR/xmlschema-2/#duration">3.2.6 duration</a>] of [<a href="http://www.w3.org/TR/xmlschema-2/">XML Schema Part 2: Datatypes</a>].</p>
        <p>If the argument is empty nodeset or string value of any node in the nodeset is not in correct format, empty string is returned.</p>
        <p>The return value is a string in the format defined for xs:duration in [<a href="http://www.w3.org/TR/xmlschema-2/#duration">3.2.6 duration</a>] of [<a href="http://www.w3.org/TR/xmlschema-2/">XML Schema Part 2: Datatypes</a>].</p>
    </description>
    <sample>
        <source><![CDATA[
<root>
    <timespan>P1M</timespan>
    <timespan>P3M</timespan>
</root>]]></source>
        <stylesheet><![CDATA[
<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:date2="http://gotdotnet.com/exslt/dates-and-times">
    <xsl:template match="/">
Average time interval is 
<xsl:value-of select="date2:avg(root/timespan)"/>.
    </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result>Average time interval is P60D.</result>
    </sample>
</function>

--- NEW FILE: GDNDatesAndTimes-day-name.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="day-name" namespace="http://gotdotnet.com/exslt/dates-and-times" prefix="date2">
    <syntax>
        <return>string</return>
        <params>
            <param optional="yes">string</param>
            <param>string</param>
        </params>
    </syntax>
    <description>
        <p>The <tt>date2:day-name</tt> function is I18N extension of 
        the <a href="http://exslt.org/date/functions/day-name/index.html"><tt>date:day-name</tt></a> function.<br/>        
        Second non-optional argument is valid according to RFC 1766 culture name 
        (supported by <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationCultureInfoClassTopic.asp">System.Globalization.CultureInfo</a> class 
        of .NET framework) in "&lt;languagecode2&gt;-&lt;country/regioncode2&gt;" format, e.g. 
        "en-US" or "he-IL".
        </p>
    </description>
    <sample>
        <source><![CDATA[
<root>
    <date>2004-09-01</date>
</root>]]></source>
        <stylesheet><![CDATA[
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:date2="http://gotdotnet.com/exslt/dates-and-times" exclude-result-prefixes="date2">   
  <xsl:template match="root">
Day name in Russian: <xsl:value-of select="date2:day-name(date, 'ru-RU')"/>
  </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result>Day name in Russian: среда</result>
    </sample>
</function>


--- NEW FILE: GDNMath-avg.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="avg" namespace="http://gotdotnet.com/exslt/math" prefix="math2">
    <syntax>
        <return>number</return>
        <params>
            <param>node-set</param>
        </params>
    </syntax>
    <description>
        <p>The <tt>math2:avg</tt> function returns average value of the nodes passed as the argument.</p>
        <p> If the node set is empty, or if the result of converting the string values of any of the nodes to a number is NaN, then NaN is returned.</p>
    </description>
    <sample>
        <source><![CDATA[<values>
    <value>7</value>
    <value>11</value>
    <value>8</value>
    <value>4</value>
</values>
]]></source>
        <stylesheet><![CDATA[<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:math2="http://gotdotnet.com/exslt/math" 
exclude-result-prefixes="math2">
    <xsl:template match="/">
        <avg>
 Average value: <xsl:value-of select="math2:avg(values/value)"/>.
        </avg>
    </xsl:template>
</xsl:stylesheet>
]]></stylesheet>
        <result> Average value: 7.5.</result>
    </sample>
</function>


--- NEW FILE: GDNFunctions.xsl ---
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:template match="function">
        <html>
            <head>
                <title>EXSLT.NET. Additional extenstion functions: <xsl:value-of select="concat(@prefix,':', @name)"/>
                </title>
            </head>
            <body>
                <h2>EXSLT.NET. Additional extenstion functions: <xsl:value-of select="concat(@prefix,':', @name)"/>
                </h2>
                <p>
                    <b>Namespace: </b>
                    <xsl:value-of select="@namespace"/>
                </p>
                <xsl:apply-templates select="syntax"/>
                <xsl:copy-of select="description"/>
                <xsl:apply-templates select="sample"/>
            </body>
        </html>
    </xsl:template>
    <xsl:template match="syntax">
        <h3>Function Syntax</h3>
        <p>
            <i>
                <xsl:value-of select="return"/>
            </i>&#xA0;<xsl:value-of select="../@prefix"/>:<xsl:value-of select="../@name"/>&#xA0;(<xsl:for-each select="params/param">
                <i>
                    <xsl:value-of select="."/>
                    <xsl:if test="@optional='yes'">?</xsl:if>
                    <xsl:if test="position() != last()">,&#xA0;</xsl:if>
                </i>
            </xsl:for-each>)</p>
    </xsl:template>
    <xsl:template match="sample">
        <h3>Example:</h3>
        <xsl:apply-templates/>
    </xsl:template>
    <xsl:template match="source">
        <h4>Source XML document:</h4>
        <pre><xsl:value-of select="."/></pre>
    </xsl:template>
    <xsl:template match="stylesheet">
        <h4>Stylesheet:</h4>
        <pre><xsl:value-of select="."/></pre>
    </xsl:template>
    <xsl:template match="result">
        <h4>Result:</h4>
        <pre><xsl:value-of select="."/></pre>
    </xsl:template>
</xsl:stylesheet>

--- NEW FILE: Functions.htm ---
<html>
  <head>
    <META http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
    <title>EXSLTNET 
                1.2 Function List</title>
    <style type="text/css">
                    body { font-family: Verdana, Arial, helvetica;}
                    .module-table {
                        width: 100%;
                    }                    
                </style>
  </head>
  <body>
    <h2>EXSLT.NET 1.2 Function List</h2>
    <hr>
    <div>EXSLT Modules:</div>
    <ol>
      <li>
        <a href="#Dates and Times">Dates and Times</a>
      </li>
      <li>
        <a href="#Common">Common</a>
      </li>
      <li>
        <a href="#Math">Math</a>
      </li>
      <li>
        <a href="#Random">Random</a>
      </li>
      <li>
        <a href="#Regular Expressions">Regular Expressions</a>
      </li>
      <li>
        <a href="#Sets">Sets</a>
      </li>
      <li>
        <a href="#Strings">Strings</a>
      </li>
    </ol>
    <div>Additional modules:</div>
    <ol>
      <li>
        <a href="#GotDotNet Dates and Times">GotDotNet Dates and Times</a>
      </li>
      <li>
        <a href="#GotDotNet Math">GotDotNet Math</a>
      </li>
      <li>
        <a href="#GotDotNet Regular Expressions">GotDotNet Regular Expressions</a>
      </li>
      <li>
        <a href="#GotDotNet Sets">GotDotNet Sets</a>
      </li>
      <li>
        <a href="#GotDotNet Strings">GotDotNet Strings</a>
      </li>
      <li>
        <a href="#GotDotNet Dynamic">GotDotNet Dynamic</a>
      </li>
    </ol>
    <hr>
    <p>
      <a name="Dates and Times">
        <div class="module-name">
          <b>Module:</b> Dates and Times</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://exslt.org/dates-and-times</div>
      <div class="module-homepage">
        <b>Homepage:</b> <a href="http://exslt.org/date/index.html">http://exslt.org/date/index.html</a></div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/format-date/index.html">date:format-date</a>
          </td>
          <td align="center">formatDate</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/parse-date/index.html">date:parse-date</a>
          </td>
          <td align="center">parseDate</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/date-time/index.html">date:date-time</a>
          </td>
          <td align="center">dateTime</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/date/index.html">date:date</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/time/index.html">date:time</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/year/index.html">date:year</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/leap-year/index.html">date:leap-year</a>
          </td>
          <td align="center">leapYear</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/month-in-year/index.html">date:month-in-year</a>
          </td>
          <td align="center">monthInYear</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/month-name/index.html">date:month-name</a>
          </td>
          <td align="center">monthName</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/month-abbreviation/index.html">date:month-abbreviation</a>
          </td>
          <td align="center">monthAbbreviation</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/week-in-year/index.html">date:week-in-year</a>
          </td>
          <td align="center">weekInYear</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/week-in-month/index.html">date:week-in-month</a>
          </td>
          <td align="center">weekInMonth</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/day-in-year/index.html">date:day-in-year</a>
          </td>
          <td align="center">dayInYear</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/day-in-month/index.html">date:day-in-month</a>
          </td>
          <td align="center">dayInMonth</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/day-of-week-in-month/index.html">date:day-of-week-in-month</a>
          </td>
          <td align="center">dayOfWeekInMonth</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/day-in-week/index.html">date:day-in-week</a>
          </td>
          <td align="center">dayInWeek</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/day-name/index.html">date:day-name</a>
          </td>
          <td align="center">dayName</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/day-abbreviation/index.html">date:day-abbreviation</a>
          </td>
          <td align="center">dayAbbreviation</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/hour-in-day/index.html">date:hour-in-day</a>
          </td>
          <td align="center">hourInDay</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/minute-in-hour/index.html">date:minute-in-hour</a>
          </td>
          <td align="center">minuteInHour</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/second-in-minute/index.html">date:second-in-minute</a>
          </td>
          <td align="center">secondInMinute</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/difference/index.html">date:difference</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/add/index.html">date:add</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/add-duration/index.html">date:add-duration</a>
          </td>
          <td align="center">addDuration</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/sum/index.html">date:sum</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/seconds/index.html">date:seconds</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/duration/index.html">date:duration</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
      </table>
    </p>
    <hr>
    <p>
      <a name="Common">
        <div class="module-name">
          <b>Module:</b> Common</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://exslt.org/common</div>
      <div class="module-homepage">
        <b>Homepage:</b> <a href="http://exslt.org/exsl/index.html">http://exslt.org/exsl/index.html</a></div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/exsl/functions/node-set/index.html">exsl:node-set</a>
          </td>
          <td align="center">nodeSet</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/exsl/functions/object-type/index.html">exsl:object-type</a>
          </td>
          <td align="center">objectType</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
      </table>
    </p>
    <hr>
    <p>
      <a name="Math">
        <div class="module-name">
          <b>Module:</b> Math</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://exslt.org/math</div>
      <div class="module-homepage">
        <b>Homepage:</b> <a href="http://exslt.org/math/index.html">http://exslt.org/math/index.html</a></div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/min/index.html">math:min</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/max/index.html">math:max</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/highest/index.html">math:highest</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/lowest/index.html">math:lowest</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/abs/index.html">math:abs</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/sqrt/index.html">math:sqrt</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/power/index.html">math:power</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/constant/index.html">math:constant</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/log/index.html">math:log</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/random/index.html">math:random</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/sin/index.html">math:sin</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/cos/index.html">math:cos</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/tan/index.html">math:tan</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/asin/index.html">math:asin</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/acos/index.html">math:acos</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/atan/index.html">math:atan</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/atan2/index.html">math:atan2</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/exp/index.html">math:exp</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
      </table>
    </p>
    <hr>
    <p>
      <a name="Random">
        <div class="module-name">
          <b>Module:</b> Random</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://exslt.org/random</div>
      <div class="module-homepage">
        <b>Homepage:</b> <a href="http://exslt.org/random/index.html">http://exslt.org/random/index.html</a></div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/random/functions/random-sequence/index.html">random:random-sequence</a>
          </td>
          <td align="center">randomSequence</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
      </table>
    </p>
    <hr>
    <p>
      <a name="Regular Expressions">
        <div class="module-name">
          <b>Module:</b> Regular Expressions</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://exslt.org/regular-expressions</div>
      <div class="module-homepage">
        <b>Homepage:</b> <a href="http://exslt.org/regexp/index.html">http://exslt.org/regexp/index.html</a></div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/regexp/functions/test/index.html">regexp:test</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/regexp/functions/match/index.html">regexp:match</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/regexp/functions/replace/index.html">regexp:replace</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
      </table>
    </p>
    <hr>
    <p>
      <a name="Sets">
        <div class="module-name">
          <b>Module:</b> Sets</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://exslt.org/sets</div>
      <div class="module-homepage">
        <b>Homepage:</b> <a href="http://exslt.org/set/index.html">http://exslt.org/set/index.html</a></div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/set/functions/difference/index.html">set:difference</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/set/functions/intersection/index.html">set:intersection</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/set/functions/distinct/index.html">set:distinct</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/set/functions/has-same-node/index.html">set:has-same-node</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/set/functions/leading/index.html">set:leading</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/set/functions/trailing/index.html">set:trailing</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
      </table>
    </p>
    <hr>
    <p>
      <a name="Strings">
        <div class="module-name">
          <b>Module:</b> Strings</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://exslt.org/strings</div>
      <div class="module-homepage">
        <b>Homepage:</b> <a href="http://exslt.org/str/index.html">http://exslt.org/str/index.html</a></div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/tokenize/index.html">str:tokenize</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/replace/index.html">str:replace</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/padding/index.html">str:padding</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/align/index.html">str:align</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/encode-uri/index.html">str:encode-uri</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/decode-uri/index.html">str:decode-uri</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/concat/index.html">str:concat</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/split/index.html">str:split</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
      </table>
    </p>
    <hr>
    <p>
      <a name="GotDotNet Dates and Times">
        <div class="module-name">
          <b>Module:</b> GotDotNet Dates and Times</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://gotdotnet.com/exslt/dates-and-times</div>
      <div class="note">
        <b>Note:</b> These functions are not part of EXSLT.</div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="GDNDatesAndTimes-avg.xml">date2:avg</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td...
 
[truncated message content]

[mvp-xml-cvs] EXSLT/v1/src/Exslt/obj/Debug Exslt.projdata,NONE,1.1 GotDotNet.Exslt.dll,NONE,1.1 GotDotNet.Exslt.dll.incr,NONE,1.1 Mvp.Xml.Exslt.dll,NONE,1.1 Mvp.Xml.Exslt.dll.incr,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/src/Exslt/obj/Debug
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/src/Exslt/obj/Debug

Added Files:
	Exslt.projdata GotDotNet.Exslt.dll GotDotNet.Exslt.dll.incr 
	Mvp.Xml.Exslt.dll Mvp.Xml.Exslt.dll.incr 
Log Message:


--- NEW FILE: Mvp.Xml.Exslt.dll ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: Exslt.projdata ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: GotDotNet.Exslt.dll.incr ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: Mvp.Xml.Exslt.dll.incr ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: GotDotNet.Exslt.dll ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/src/MethodRenamer .cvsignore,NONE,1.1 App.config,NONE,1.1 MethodRenamer.cs,NONE,1.1 MethodRenamer.csproj,NONE,1.1 MethodRenamer.csproj.user,NONE,1.1 MethodRenamer.csproj.vspscc,NONE,1.1 MethodRenamer.exe,NONE,1.1 MethodRenamer.exe.config,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/src/MethodRenamer
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/src/MethodRenamer

Added Files:
	.cvsignore App.config MethodRenamer.cs MethodRenamer.csproj 
	MethodRenamer.csproj.user MethodRenamer.csproj.vspscc 
	MethodRenamer.exe MethodRenamer.exe.config 
Log Message:


--- NEW FILE: .cvsignore ---
bin
obj
*.user
*.suo
*.pdb
*.exe
--- NEW FILE: MethodRenamer.exe ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: MethodRenamer.csproj.vspscc ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: MethodRenamer.exe.config ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: MethodRenamer.csproj ---
<VisualStudioProject>
    <CSHARP
        ProjectType = "Local"
        ProductVersion = "7.10.3077"
        SchemaVersion = "2.0"
        ProjectGuid = "{A22418E5-DCE6-4D12-A016-151EA614A787}"
    >
        <Build>
            <Settings
                ApplicationIcon = ""
                AssemblyKeyContainerName = ""
                AssemblyName = "MethodRenamer"
                AssemblyOriginatorKeyFile = ""
                DefaultClientScript = "JScript"
                DefaultHTMLPageLayout = "Grid"
                DefaultTargetSchema = "IE50"
                DelaySign = "false"
                OutputType = "Exe"
                PreBuildEvent = ""
                PostBuildEvent = ""
                RootNamespace = "GotDotNet.Exslt.MethodRenamer"
                RunPostBuildEvent = "OnBuildSuccess"
                StartupObject = "Mvp.Xml.Exslt.MethodRenamer.MethodRenamer"
            >
                <Config
                    Name = "Debug"
                    AllowUnsafeBlocks = "false"
                    BaseAddress = "285212672"
                    CheckForOverflowUnderflow = "false"
                    ConfigurationOverrideFile = ""
                    DefineConstants = "DEBUG;TRACE"
                    DocumentationFile = ""
                    DebugSymbols = "true"
                    FileAlignment = "4096"
                    IncrementalBuild = "true"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "false"
                    OutputPath = ".\"
                    RegisterForComInterop = "false"
                    RemoveIntegerChecks = "false"
                    TreatWarningsAsErrors = "false"
                    WarningLevel = "4"
                />
                <Config
                    Name = "Release"
                    AllowUnsafeBlocks = "false"
                    BaseAddress = "285212672"
                    CheckForOverflowUnderflow = "false"
                    ConfigurationOverrideFile = ""
                    DefineConstants = "TRACE"
                    DocumentationFile = ""
                    DebugSymbols = "false"
                    FileAlignment = "4096"
                    IncrementalBuild = "false"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "true"
                    OutputPath = ".\"
                    RegisterForComInterop = "false"
                    RemoveIntegerChecks = "false"
                    TreatWarningsAsErrors = "false"
                    WarningLevel = "4"
                />
            </Settings>
            <References>
                <Reference
                    Name = "System"
                    AssemblyName = "System"
                    HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.0.3705\System.dll"
                />
                <Reference
                    Name = "System.Data"
                    AssemblyName = "System.Data"
                    HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.0.3705\System.Data.dll"
                />
                <Reference
                    Name = "System.XML"
                    AssemblyName = "System.Xml"
                    HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.0.3705\System.XML.dll"
                />
            </References>
        </Build>
        <Files>
            <Include>
                <File
                    RelPath = "App.config"
                    BuildAction = "None"
                />
                <File
                    RelPath = "MethodRenamer.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
            </Include>
        </Files>
    </CSHARP>
</VisualStudioProject>


--- NEW FILE: MethodRenamer.cs ---
using System;
using System.Collections.Specialized;
using System.Collections;
using System.IO;
using System.Text;
using System.Configuration;

namespace Mvp.Xml.Exslt.MethodRenamer {	
    /// <summary>
    /// An utility to rename methods in MSIL code.
    /// </summary>
    public class MethodRenamer {		
        [STAThread]
        static void Main(string[] args) {
            IDictionary dictionary = (IDictionary)ConfigurationSettings.GetConfig("names");			
            //Reads input IL code
            StreamReader reader = new StreamReader(args[0]);
            //Writes output IL code
            StreamWriter writer = new StreamWriter(args[1]);
            string line;
            //Go read line by line
            while ((line = reader.ReadLine())!=null) {
                //Method definition?
                if (line.Trim().StartsWith(".method")) {
                    writer.WriteLine(line);
                    line = reader.ReadLine();
                    if (line.IndexOf("(")!=-1) {
                        string methodName = line.Trim().Substring(0, line.Trim().IndexOf("("));
                        if (dictionary.Contains(methodName)) {
                            writer.WriteLine(line.Replace(methodName+"(", 
                                "'"+(string)dictionary[methodName]+"'("));                        
                            Console.WriteLine("Found '" + methodName + "' method, renamed to '" + 
                                dictionary[methodName] + "'");                                            
                        } 
                        else
                            writer.WriteLine(line);                                   
                    } 
                    else
                        writer.WriteLine(line);
                } 
                else
                    writer.WriteLine(line);
            }
            reader.Close();
            writer.Close();
        }
    }
}
--- NEW FILE: MethodRenamer.csproj.user ---
<VisualStudioProject>
    <CSHARP LastOpenVersion = "7.10.3077" >
        <Build>
            <Settings ReferencePath = "" >
                <Config
                    Name = "Debug"
                    EnableASPDebugging = "false"
                    EnableASPXDebugging = "false"
                    EnableUnmanagedDebugging = "false"
                    EnableSQLServerDebugging = "false"
                    RemoteDebugEnabled = "false"
                    RemoteDebugMachine = ""
                    StartAction = "Project"
                    StartArguments = ""
                    StartPage = ""
                    StartProgram = ""
                    StartURL = ""
                    StartWorkingDirectory = ""
                    StartWithIE = "false"
                />
                <Config
                    Name = "Release"
                    EnableASPDebugging = "false"
                    EnableASPXDebugging = "false"
                    EnableUnmanagedDebugging = "false"
                    EnableSQLServerDebugging = "false"
                    RemoteDebugEnabled = "false"
                    RemoteDebugMachine = ""
                    StartAction = "Project"
                    StartArguments = ""
                    StartPage = ""
                    StartProgram = ""
                    StartURL = ""
                    StartWorkingDirectory = ""
                    StartWithIE = "false"
                />
            </Settings>
        </Build>
        <OtherProjectSettings
            CopyProjectDestinationFolder = ""
            CopyProjectUncPath = ""
            CopyProjectOption = "0"
            ProjectView = "ProjectFiles"
            ProjectTrust = "0"
        />
    </CSHARP>
</VisualStudioProject>


--- NEW FILE: App.config ---
(This appears to be a binary file; contents omitted.)

[mvp-xml-cvs] EXSLT/v1/doc Functions.htm,NONE,1.1 Functions.xml,NONE,1.1 Functions.xslt,NONE,1.1 GDNDatesAndTimes-avg.xml,NONE,1.1 GDNDatesAndTimes-day-abbreviation.xml,NONE,1.1 GDNDatesAndTimes-day-name.xml,NONE,1.1 GDNDatesAndTimes-max.xml,NONE,1.1 GDNDatesAndTimes-min.xml,NONE,1.1 GDNDatesAndTimes-month-abbreviation.xml,NONE,1.1 GDNDatesAndTimes-month-name.xml,NONE,1.1 GDNDynamic-evaluate.xml,NONE,1.1 GDNFunctions.xsl,NONE,1.1 GDNMath-avg.xml,NONE,1.1 GDNRegularExpressions-tokenize.xml,NONE,1.1 GDNSets-subset.xml,NONE,1.1 GDNStrings-lowercase.xml,NONE,1.1 GDNStrings-uppercase.xml,NONE,1.1 buildFuncList.cmd,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/doc
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/doc

Added Files:
	Functions.htm Functions.xml Functions.xslt 
	GDNDatesAndTimes-avg.xml GDNDatesAndTimes-day-abbreviation.xml 
	GDNDatesAndTimes-day-name.xml GDNDatesAndTimes-max.xml 
	GDNDatesAndTimes-min.xml 
	GDNDatesAndTimes-month-abbreviation.xml 
	GDNDatesAndTimes-month-name.xml GDNDynamic-evaluate.xml 
	GDNFunctions.xsl GDNMath-avg.xml 
	GDNRegularExpressions-tokenize.xml GDNSets-subset.xml 
	GDNStrings-lowercase.xml GDNStrings-uppercase.xml 
	buildFuncList.cmd 
Log Message:


--- NEW FILE: GDNDatesAndTimes-month-abbreviation.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="month-abbreviation" namespace="http://gotdotnet.com/exslt/dates-and-times" prefix="date2">
    <syntax>
        <return>string</return>
        <params>
            <param optional="yes">string</param>
            <param>string</param>
        </params>
    </syntax>
    <description>
        <p>The <tt>date2:month-abbreviation</tt> function is I18N extension of 
        the <a href="http://exslt.org/date/functions/month-abbreviation/index.html"><tt>date:month-abbreviation</tt></a> function.<br/>        
        Second non-optional argument is valid according to RFC 1766 culture name 
        (supported by <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationCultureInfoClassTopic.asp">System.Globalization.CultureInfo</a> class 
        of .NET framework) in "&lt;languagecode2&gt;-&lt;country/regioncode2&gt;" format, e.g. 
        "en-US" or "he-IL".
        </p>
    </description>
    <sample>
        <source><![CDATA[
<root>
    <date>2004-09-01</date>
</root>]]></source>
        <stylesheet><![CDATA[
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:date2="http://gotdotnet.com/exslt/dates-and-times" exclude-result-prefixes="date2">   
  <xsl:template match="root">
Month name abbreviation in Turkish: <xsl:value-of select="date2:month-abbreviation(date, 'tr-TR')"/>
  </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result>Month name abbreviation in Turkish: Eyl</result>
    </sample>
</function>


--- NEW FILE: Functions.xml ---
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="Functions.xslt"?>
<modules version="1.2">
    <module namespace="http://exslt.org/dates-and-times" prefix="date" name="Dates and Times" homepage="http://exslt.org/date/index.html" is-exslt-module="yes">
        <function name="format-date" alias="formatDate" descriptionURL="http://exslt.org/date/functions/format-date/index.html" supported="yes"/>
        <function name="parse-date" alias="parseDate" descriptionURL="http://exslt.org/date/functions/parse-date/index.html" supported="yes"/>
        <function name="date-time" alias="dateTime" descriptionURL="http://exslt.org/date/functions/date-time/index.html" supported="yes"/>
        <function name="date" descriptionURL="http://exslt.org/date/functions/date/index.html" supported="yes"/>
        <function name="time" descriptionURL="http://exslt.org/date/functions/time/index.html" supported="yes"/>
        <function name="year" descriptionURL="http://exslt.org/date/functions/year/index.html" supported="yes"/>
        <function name="leap-year" alias="leapYear" descriptionURL="http://exslt.org/date/functions/leap-year/index.html" supported="yes"/>
        <function name="month-in-year" alias="monthInYear" descriptionURL="http://exslt.org/date/functions/month-in-year/index.html" supported="yes"/>
        <function name="month-name" alias="monthName" descriptionURL="http://exslt.org/date/functions/month-name/index.html" supported="yes"/>
        <function name="month-abbreviation" alias="monthAbbreviation" descriptionURL="http://exslt.org/date/functions/month-abbreviation/index.html" supported="yes"/>
        <function name="week-in-year" alias="weekInYear" descriptionURL="http://exslt.org/date/functions/week-in-year/index.html" supported="yes"/>
        <function name="week-in-month" alias="weekInMonth" descriptionURL="http://exslt.org/date/functions/week-in-month/index.html" supported="yes"/>
        <function name="day-in-year" alias="dayInYear" descriptionURL="http://exslt.org/date/functions/day-in-year/index.html" supported="yes"/>
        <function name="day-in-month" alias="dayInMonth" descriptionURL="http://exslt.org/date/functions/day-in-month/index.html" supported="yes"/>
        <function name="day-of-week-in-month" alias="dayOfWeekInMonth" descriptionURL="http://exslt.org/date/functions/day-of-week-in-month/index.html" supported="yes"/>
        <function name="day-in-week" alias="dayInWeek" descriptionURL="http://exslt.org/date/functions/day-in-week/index.html" supported="yes"/>
        <function name="day-name" alias="dayName" descriptionURL="http://exslt.org/date/functions/day-name/index.html" supported="yes"/>
        <function name="day-abbreviation" alias="dayAbbreviation" descriptionURL="http://exslt.org/date/functions/day-abbreviation/index.html" supported="yes"/>
        <function name="hour-in-day" alias="hourInDay" descriptionURL="http://exslt.org/date/functions/hour-in-day/index.html" supported="yes"/>
        <function name="minute-in-hour" alias="minuteInHour" descriptionURL="http://exslt.org/date/functions/minute-in-hour/index.html" supported="yes"/>
        <function name="second-in-minute" alias="secondInMinute" descriptionURL="http://exslt.org/date/functions/second-in-minute/index.html" supported="yes"/>
        <function name="difference" descriptionURL="http://exslt.org/date/functions/difference/index.html" supported="yes"/>
        <function name="add" descriptionURL="http://exslt.org/date/functions/add/index.html" supported="yes"/>
        <function name="add-duration" alias="addDuration" descriptionURL="http://exslt.org/date/functions/add-duration/index.html" supported="yes"/>
        <function name="sum" descriptionURL="http://exslt.org/date/functions/sum/index.html" supported="yes"/>
        <function name="seconds" descriptionURL="http://exslt.org/date/functions/seconds/index.html" supported="yes"/>
        <function name="duration" descriptionURL="http://exslt.org/date/functions/duration/index.html" supported="yes"/>
    </module>
    <module namespace="http://exslt.org/common" prefix="exsl" name="Common" homepage="http://exslt.org/exsl/index.html" is-exslt-module="yes">
        <function name="node-set" alias="nodeSet" descriptionURL="http://exslt.org/exsl/functions/node-set/index.html" supported="yes"/>
        <function name="object-type" alias="objectType" descriptionURL="http://exslt.org/exsl/functions/object-type/index.html" supported="yes"/>
    </module>
    <module namespace="http://exslt.org/math" prefix="math" name="Math" homepage="http://exslt.org/math/index.html" is-exslt-module="yes">
        <function name="min" descriptionURL="http://exslt.org/math/functions/min/index.html" supported="yes"/>
        <function name="max" descriptionURL="http://exslt.org/math/functions/max/index.html" supported="yes"/>
        <function name="highest" descriptionURL="http://exslt.org/math/functions/highest/index.html" supported="yes"/>
        <function name="lowest" descriptionURL="http://exslt.org/math/functions/lowest/index.html" supported="yes"/>
        <function name="abs" descriptionURL="http://exslt.org/math/functions/abs/index.html" supported="yes"/>
        <function name="sqrt" descriptionURL="http://exslt.org/math/functions/sqrt/index.html" supported="yes"/>
        <function name="power" descriptionURL="http://exslt.org/math/functions/power/index.html" supported="yes"/>
        <function name="constant" descriptionURL="http://exslt.org/math/functions/constant/index.html" supported="yes"/>
        <function name="log" descriptionURL="http://exslt.org/math/functions/log/index.html" supported="yes"/>
        <function name="random" descriptionURL="http://exslt.org/math/functions/random/index.html" supported="yes"/>
        <function name="sin" descriptionURL="http://exslt.org/math/functions/sin/index.html" supported="yes"/>
        <function name="cos" descriptionURL="http://exslt.org/math/functions/cos/index.html" supported="yes"/>
        <function name="tan" descriptionURL="http://exslt.org/math/functions/tan/index.html" supported="yes"/>
        <function name="asin" descriptionURL="http://exslt.org/math/functions/asin/index.html" supported="yes"/>
        <function name="acos" descriptionURL="http://exslt.org/math/functions/acos/index.html" supported="yes"/>
        <function name="atan" descriptionURL="http://exslt.org/math/functions/atan/index.html" supported="yes"/>
        <function name="atan2" descriptionURL="http://exslt.org/math/functions/atan2/index.html" supported="yes"/>
        <function name="exp" descriptionURL="http://exslt.org/math/functions/exp/index.html" supported="yes"/>
    </module>
    <module namespace="http://exslt.org/random" prefix="random" name="Random" homepage="http://exslt.org/random/index.html" is-exslt-module="yes">
		<function name="random-sequence" alias="randomSequence" descriptionURL="http://exslt.org/random/functions/random-sequence/index.html" supported="yes"/>
    </module>
    <module namespace="http://exslt.org/regular-expressions" prefix="regexp" name="Regular Expressions" homepage="http://exslt.org/regexp/index.html" is-exslt-module="yes">
        <function name="test" descriptionURL="http://exslt.org/regexp/functions/test/index.html" supported="yes"/>
        <function name="match" descriptionURL="http://exslt.org/regexp/functions/match/index.html" supported="yes"/>
        <function name="replace" descriptionURL="http://exslt.org/regexp/functions/replace/index.html" supported="yes"/>
    </module>
    <module namespace="http://exslt.org/sets" prefix="set" name="Sets" homepage="http://exslt.org/set/index.html" is-exslt-module="yes">
        <function name="difference" descriptionURL="http://exslt.org/set/functions/difference/index.html" supported="yes"/>
        <function name="intersection" descriptionURL="http://exslt.org/set/functions/intersection/index.html" supported="yes"/>
        <function name="distinct" descriptionURL="http://exslt.org/set/functions/distinct/index.html" supported="yes"/>
        <function name="has-same-node" descriptionURL="http://exslt.org/set/functions/has-same-node/index.html" supported="yes"/>
        <function name="leading" descriptionURL="http://exslt.org/set/functions/leading/index.html" supported="yes"/>
        <function name="trailing" descriptionURL="http://exslt.org/set/functions/trailing/index.html" supported="yes"/>
    </module>
    <module namespace="http://exslt.org/strings" prefix="str" name="Strings" homepage="http://exslt.org/str/index.html" is-exslt-module="yes">
        <function name="tokenize" descriptionURL="http://exslt.org/str/functions/tokenize/index.html" supported="yes"/>
        <function name="replace" descriptionURL="http://exslt.org/str/functions/replace/index.html" supported="yes"/>
        <function name="padding" descriptionURL="http://exslt.org/str/functions/padding/index.html" supported="yes"/>
        <function name="align" descriptionURL="http://exslt.org/str/functions/align/index.html" supported="yes"/>
        <function name="encode-uri" descriptionURL="http://exslt.org/str/functions/encode-uri/index.html" supported="yes"/>
        <function name="decode-uri" descriptionURL="http://exslt.org/str/functions/decode-uri/index.html" supported="yes"/>
        <function name="concat" descriptionURL="http://exslt.org/str/functions/concat/index.html" supported="yes"/>
        <function name="split" descriptionURL="http://exslt.org/str/functions/split/index.html" supported="yes"/>
    </module>
    <!-- Additional EXSLT.NET functions -->
    <module namespace="http://gotdotnet.com/exslt/dates-and-times" prefix="date2" name="GotDotNet Dates and Times" is-exslt-module="no">
        <function name="avg" descriptionURL="GDNDatesAndTimes-avg.xml" supported="yes"/>
        <function name="min" descriptionURL="GDNDatesAndTimes-min.xml" supported="yes"/>
        <function name="max" descriptionURL="GDNDatesAndTimes-max.xml" supported="yes"/>
        <function name="day-name" alias="dayName" descriptionURL="GDNDatesAndTimes-day-name.xml" supported="yes"/>
        <function name="day-abbreviation" alias="dayAbbreviation" descriptionURL="GDNDatesAndTimes-day-abbreviation.xml" supported="yes"/>        
        <function name="month-name" alias="monthName" descriptionURL="GDNDatesAndTimes-month-name.xml" supported="yes"/>
        <function name="month-abbreviation" alias="monthAbbreviation" descriptionURL="GDNDatesAndTimes-month-abbreviation.xml" supported="yes"/>
    </module>
    <module namespace="http://gotdotnet.com/exslt/math" prefix="math2" name="GotDotNet Math" is-exslt-module="no">
        <function name="avg" descriptionURL="GDNMath-avg.xml" supported="yes"/>
    </module>
    <module namespace="http://gotdotnet.com/exslt/regular-expressions" prefix="regexp2" name="GotDotNet Regular Expressions" is-exslt-module="no">
        <function name="tokenize" descriptionURL="GDNRegularExpressions-tokenize.xml" supported="yes"/>
    </module>
    <module namespace="http://gotdotnet.com/exslt/sets" prefix="set2" name="GotDotNet Sets" is-exslt-module="no">
        <function name="subset" descriptionURL="GDNSets-subset.xml" supported="yes"/>
    </module>
     <module namespace="http://gotdotnet.com/exslt/strings" prefix="str2" name="GotDotNet Strings" is-exslt-module="no">
        <function name="uppercase" descriptionURL="GDNStrings-uppercase.xml" supported="yes"/>
        <function name="lowercase" descriptionURL="GDNStrings-lowercase.xml" supported="yes"/>
    </module>
    <module namespace="http://gotdotnet.com/exslt/dynamic" prefix="dyn2" name="GotDotNet Dynamic" is-exslt-module="no">
        <function name="evaluate" descriptionURL="GDNDynamic-evaluate.xml" supported="yes"/>
    </module>
</modules>

--- NEW FILE: GDNDatesAndTimes-min.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="min" namespace="http://gotdotnet.com/exslt/dates-and-times" prefix="date2">
    <syntax>
        <return>string</return>
        <params>
            <param>node-set</param>
        </params>
    </syntax>
    <description>
        <p>The <tt>date2:avg</tt> function returns minimum duration.<br/> 
       String values of nodes in the argument nodeset must be in the format defined for xs:duration in [<a href="http://www.w3.org/TR/xmlschema-2/#duration">3.2.6 duration</a>] of [<a href="http://www.w3.org/TR/xmlschema-2/">XML Schema Part 2: Datatypes</a>].</p>
        <p>If the argument is empty nodeset or string value of any node in the nodeset is not in correct format, empty string is returned.</p>
        <p>The return value is a string in the format defined for xs:duration in [<a href="http://www.w3.org/TR/xmlschema-2/#duration">3.2.6 duration</a>] of [<a href="http://www.w3.org/TR/xmlschema-2/">XML Schema Part 2: Datatypes</a>].</p>
    </description>
    <sample>
        <source><![CDATA[
<root>
    <timespan>P1M</timespan>
    <timespan>P3M</timespan>
</root>]]></source>
        <stylesheet><![CDATA[
<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:date2="http://gotdotnet.com/exslt/dates-and-times">
    <xsl:template match="/">
Minimum time interval is 
<xsl:value-of select="date2:min(root/timespan)"/>.
    </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result>Minimum time interval is P30D.</result>
    </sample>
</function>

--- NEW FILE: GDNDynamic-evaluate.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="evaluate" namespace="http://gotdotnet.com/exslt/dynamic" prefix="dyn2">
    <syntax>
        <return>object</return>
        <params>
            <param>node-set</param>
            <param>string</param>
            <param optional="yes">string</param>
        </params>        
    </syntax>
    <description>
        <p>The <tt>dyn2:evaluate</tt> function evaluates a string as an XPath 
        expression and returns the resulting value, which might be a boolean, 
        number, string, node set, result tree fragment or external object.</p>
        <p>First node-set argument provides a context node (the first node 
        in the passed node-set), such that 
        selection paths are evaluated relative to it. Second string argument 
        is the XPath expression to be evaluated. Third optional string argument
        provides namespace bindings to be used to resolve namespace prefixes in 
        the XPath expression. Namespaces are defined in the XML style, as a 
        space separated list of namespace declaration attributes.</p>                
        <p>All namespace prefixes that are in scope for the context node (or its 
        parent node if the context node isn't element node) can be referenced in the 
        evaluated XPath expression. Note though that relying on namespace prefixes 
        defined in the source XML is very unreliable. We encourage users to define 
        namespace bindings explicitly in the third argument instead.</p>
        <p>If the node-set passed as first argument is empty (no context node) or 
        the expression string passed as the second argument is an invalid 
        XPath expression (including an empty string), this function returns an 
        empty string. Malformed namespace declarations in the third argument are 
        ignored.</p>
        <p>Note that this function is more limited than EXSLT's 
        <a href="http://exslt.org/dyn/functions/evaluate/index.html">dyn:evaluate()</a> 
        function. More formally:
        <ul>
            <li>No context position and context size information is available.</li>
            <li>No variable bindings - this function is unable to evaluate XPath 
            expressions, which contain variable references!</li>
            <li>No custom extension functions - only core XPath functions and
            all extension functions, supported by EXSLT.NET are available.</li>
            <li>No current node, so the expression cannot contain the 
            <tt>current()</tt> function calls.</li>
            <li>No key definition information available, so the expression cannot 
            contain the <tt>key()</tt> function calls.</li>
            <li>No custom decimal format definitions are avilable, so the expression 
            cannot contain the <tt>fomat-number()</tt> function calls that refer to
            a <tt>&lt;xsl:decimal-format></tt> definition.</li>
        </ul>
        </p>
        <p> You should only use this function if the expression must be constructed 
        dynamically - otherwise it is much more efficient to use the expression 
        literally. For expressions that simply give an element or attribute's 
        name (to select a child element or attribute), it is more efficient to 
        use an expression in the style:<br/>
        <code>*[name() = $expression]</code>
        </p>        
    </description>
    <sample>
        <source><![CDATA[<data xmlns:o="http://orders.com">
  <orders>
    <order id="o234">T-Shirt</order>
    <order id="o12">Polo Shirt</order>
    <order id="o332">Shoes</order>
  </orders>
  <orders xmlns="http://orders.com">
    <order id="o11">Foo</order>
    <order id="o22">Bar</order>
    <order id="o44">Baz</order>
  </orders>
  <path>/data/orders/order[@id='o12']</path>
  <path2>orders/order[@id='o12']</path2>  
  <path7>foo:orders/foo:order[@id='o11']</path7>
</data>]]></source>
        <stylesheet><![CDATA[<?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:dyn2="http://gotdotnet.com/exslt/dynamic" exclude-result-prefixes="dyn2">
    <xsl:output indent="yes" omit-xml-declaration="yes"/>
    <xsl:template match="data">
        <out>
            <test1>                
                <xsl:value-of select="dyn2:evaluate(., concat('2', '+', '2'))"/>
            </test1>
            <test2>                
                <xsl:copy-of select="dyn2:evaluate(., /data/path)"/>
            </test2>
            <test3>                
                <xsl:value-of select="dyn2:evaluate(., /data/path)/@id"/>
            </test3>
            <test4>                
                <xsl:copy-of select="dyn2:evaluate(., /data/path2)"/>
            </test4>                                                 
            <test5>                
                <xsl:copy-of select="dyn2:evaluate(., 'o:orders/o:order')"/>
            </test5>            
            <test6>
                <xsl:variable name="namespaces">xmlns:foo="http://orders.com" xmlns:bar='http://bar.com/'</xsl:variable>                                
                <xsl:copy-of select="dyn2:evaluate(., /data/path7, $namespaces)"/>
            </test6>                                            
        </out>
    </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result><![CDATA[<out>
  <test1>4</test1>
  <test2>
    <order id="o12" xmlns:o="http://orders.com">Polo Shirt</order>
  </test2>
  <test3>o12</test3>
  <test4>
    <order id="o12" xmlns:o="http://orders.com">Polo Shirt</order>
  </test4>
  <test5>
    <order id="o11" xmlns:o="http://orders.com" xmlns="http://orders.com">Foo</order>
    <order id="o22" xmlns:o="http://orders.com" xmlns="http://orders.com">Bar</order>
    <order id="o44" xmlns:o="http://orders.com" xmlns="http://orders.com">Baz</order>
  </test5>
  <test6>
    <order id="o11" xmlns:o="http://orders.com" xmlns="http://orders.com">Foo</order>
  </test6>
</out>]]></result>
    </sample>
</function>

--- NEW FILE: GDNStrings-uppercase.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="uppercase" namespace="http://gotdotnet.com/exslt/strings" prefix="str2">
    <syntax>
        <return>string</return>
        <params>
            <param>string</param>
        </params>
    </syntax>
    <description>
        <p>This function returns a copy of argument string in uppercase, using the casing rules of the current culture.</p>
    </description>
    <sample>
        <source><![CDATA[<input>The Quick Brown Fox Jumps Over a Lazy Dog.</input>]]></source>
        <stylesheet><![CDATA[<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:str2="http://gotdotnet.com/exslt/strings" 
extension-element-prefixes="str2">
    <xsl:template match="/">
        <out><xsl:value-of select="str2:uppercase(input)"/></out>
    </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result><![CDATA[<out>THE QUICK BROWN FOX JUMPS OVER A LAZY DOG.</out>]]></result>
    </sample>
</function>


--- NEW FILE: GDNStrings-lowercase.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="lowercase" namespace="http://gotdotnet.com/exslt/strings" prefix="str2">
    <syntax>
        <return>string</return>
        <params>
            <param>string</param>
        </params>
    </syntax>
    <description>
        <p>This function returns a copy of argument string in lowercase, using the casing rules of the current culture.</p>
    </description>
    <sample>
        <source><![CDATA[<input>The Quick Brown Fox Jumps Over a Lazy Dog.</input>]]></source>
        <stylesheet><![CDATA[<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:str2="http://gotdotnet.com/exslt/strings" 
extension-element-prefixes="str2">
    <xsl:template match="/">
        <out><xsl:value-of select="str2:lowercase(input)"/></out>
    </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result><![CDATA[<out>the quick brown fox jumps over a lazy dog.</out>]]></result>
    </sample>
</function>

--- NEW FILE: GDNDatesAndTimes-max.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="max" namespace="http://gotdotnet.com/exslt/dates-and-times" prefix="date2">
    <syntax>
        <return>string</return>
        <params>
            <param>node-set</param>
        </params>
    </syntax>
    <description>
        <p>The <tt>date2:avg</tt> function returns maximum duration.<br/> 
       String values of nodes in the argument nodeset must be in the format defined for xs:duration in [<a href="http://www.w3.org/TR/xmlschema-2/#duration">3.2.6 duration</a>] of [<a href="http://www.w3.org/TR/xmlschema-2/">XML Schema Part 2: Datatypes</a>].</p>
        <p>If the argument is empty nodeset or string value of any node in the nodeset is not in correct format, empty string is returned.</p>
        <p>The return value is a string in the format defined for xs:duration in [<a href="http://www.w3.org/TR/xmlschema-2/#duration">3.2.6 duration</a>] of [<a href="http://www.w3.org/TR/xmlschema-2/">XML Schema Part 2: Datatypes</a>].</p>
    </description>
    <sample>
        <source><![CDATA[
<root>
    <timespan>P1M</timespan>
    <timespan>P3M</timespan>
</root>]]></source>
        <stylesheet><![CDATA[
<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:date2="http://gotdotnet.com/exslt/dates-and-times">
    <xsl:template match="/">
Maximum time interval is 
<xsl:value-of select="date2:max(root/timespan)"/>.
    </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result>Maximum time interval is P90D.</result>
    </sample>
</function>

--- NEW FILE: GDNDatesAndTimes-month-name.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="month-name" namespace="http://gotdotnet.com/exslt/dates-and-times" prefix="date2">
    <syntax>
        <return>string</return>
        <params>
            <param optional="yes">string</param>
            <param>string</param>
        </params>
    </syntax>
    <description>
        <p>The <tt>date2:month-name</tt> function is I18N extension of 
        the <a href="http://exslt.org/date/functions/month-name/index.html"><tt>date:month-name</tt></a> function.<br/>        
        Second non-optional argument is valid according to RFC 1766 culture name 
        (supported by <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationCultureInfoClassTopic.asp">System.Globalization.CultureInfo</a> class 
        of .NET framework) in "&lt;languagecode2&gt;-&lt;country/regioncode2&gt;" format, e.g. 
        "en-US" or "he-IL".
        </p>
    </description>
    <sample>
        <source><![CDATA[
<root>
    <date>2004-09-01</date>
</root>]]></source>
        <stylesheet><![CDATA[
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:date2="http://gotdotnet.com/exslt/dates-and-times" exclude-result-prefixes="date2">   
  <xsl:template match="root">
Month name in Italian: <xsl:value-of select="date2:month-name(date, 'it-IT')"/>
  </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result>Month name in Italian: settembre</result>
    </sample>
</function>


--- NEW FILE: Functions.xslt ---
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:exslt="http://exslt.org/documentation" exclude-result-prefixes="exslt">
    <xsl:output indent="yes" encoding="ISO8859-1"/>
<!--    <xsl:template match="modules">
        <modules>
            <xsl:for-each select="module">
                <module namespace="{@namespace}">
                    <xsl:variable name="doc" select="document(@url)/*"/>
                    <xsl:variable name="prefix" select="$doc/@prefix"/>
                    <xsl:attribute name="prefix"><xsl:value-of select="$doc/@prefix"/></xsl:attribute>
                    <xsl:attribute name="name"><xsl:value-of select="$doc/exslt:name"/></xsl:attribute>
                    <xsl:attribute name="homepage"><xsl:value-of select="concat('http://exslt.org/', $prefix, '/index.html')"/></xsl:attribute>
                    <xsl:for-each select="$doc/exslt:functions/exslt:function">
                        <function name="{@name}" descriptionURL="{concat('http://exslt.org/', $prefix, '/functions/', @name, '/index.html')}" supported="yes"/>
                    </xsl:for-each>
                </module>
            </xsl:for-each>
        </modules>
    </xsl:template> -->
    <xsl:template match="/">
        <html>
            <head>
                <title>EXSLTNET 
                <xsl:value-of select="modules/@version"/> Function List</title>
                <style type="text/css">
                    body { font-family: Verdana, Arial, helvetica;}
                    .module-table {
                        width: 100%;
                    }                    
                </style>
            </head>
            <body>
                <h2>EXSLT.NET <xsl:value-of select="modules/@version"/> Function List</h2>
                <hr/>
                <div>EXSLT Modules:</div>
                <ol>                                
                    <xsl:apply-templates select="modules/module[@is-exslt-module='yes']" mode="toc"/>
                </ol>
                <div>Additional modules:</div>
                <ol>                                
                    <xsl:apply-templates select="modules/module[@is-exslt-module='no']" mode="toc"/>
                </ol>
                <hr/>
                <xsl:apply-templates select="modules/module"/>
            </body>
        </html>                
    </xsl:template>
    <xsl:template match="module" mode="toc">
        <li>
            <a href="#{@name}"><xsl:value-of select="@name"/></a>
        </li>       
    </xsl:template>
    <xsl:template match="module">        
        <p>
        <a name="{@name}">
        <div class="module-name"><b>Module:</b>&#xA0;<xsl:value-of select="@name"/></div></a>        
        <div class="module-ns"><b>Namespace:</b>&#xA0;<xsl:value-of select="@namespace"/></div>
        <xsl:if test="@homepage">
            <div class="module-homepage"><b>Homepage:</b>&#xA0;<a href="{@homepage}"><xsl:value-of select="@homepage"/></a></div>
        </xsl:if>
        <xsl:if test="@is-exslt-module='no'">
            <div class="note"><b>Note:</b> These functions are not part of EXSLT.</div>
        </xsl:if>
        <table border="1" class="module-table">
            <tr>
                <th>Function name</th>
                <th>Alias</th>
                <th>Supported</th>               
            </tr>
            <xsl:for-each select="function">
                <tr>
                    <td>
                    <xsl:choose>
                        <xsl:when test="@descriptionURL">
                            <a href="{@descriptionURL}"><xsl:value-of select="concat(../@prefix, ':', @name)"/></a>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:value-of select="concat(../@prefix, ':', @name)"/>
                        </xsl:otherwise>
                    </xsl:choose>
                    </td>
                    <td align="center">
                        <xsl:choose>
                            <xsl:when test="@alias">
                                <xsl:value-of select="@alias"/>
                            </xsl:when>
                            <xsl:otherwise>-</xsl:otherwise>
                        </xsl:choose>
                    </td>
                    <td align="center">
                    <xsl:attribute name="style">
                        <xsl:choose>
                            <xsl:when test="@supported='yes'">color:green;</xsl:when>
                            <xsl:otherwise>color:red;</xsl:otherwise>
                        </xsl:choose>
                    </xsl:attribute>
                    <xsl:value-of select="@supported"/></td>
                </tr>
            </xsl:for-each>
        </table>
        </p>
        <hr/>
    </xsl:template>
</xsl:stylesheet>

--- NEW FILE: GDNDatesAndTimes-avg.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="avg" namespace="http://gotdotnet.com/exslt/dates-and-times" prefix="date2">
    <syntax>
        <return>string</return>
        <params>
            <param>node-set</param>
        </params>
    </syntax>
    <description>
        <p>The <tt>date2:avg</tt> function returns average duration.<br/> 
       String values of nodes in the argument nodeset must be in the format defined for xs:duration in [<a href="http://www.w3.org/TR/xmlschema-2/#duration">3.2.6 duration</a>] of [<a href="http://www.w3.org/TR/xmlschema-2/">XML Schema Part 2: Datatypes</a>].</p>
        <p>If the argument is empty nodeset or string value of any node in the nodeset is not in correct format, empty string is returned.</p>
        <p>The return value is a string in the format defined for xs:duration in [<a href="http://www.w3.org/TR/xmlschema-2/#duration">3.2.6 duration</a>] of [<a href="http://www.w3.org/TR/xmlschema-2/">XML Schema Part 2: Datatypes</a>].</p>
    </description>
    <sample>
        <source><![CDATA[
<root>
    <timespan>P1M</timespan>
    <timespan>P3M</timespan>
</root>]]></source>
        <stylesheet><![CDATA[
<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:date2="http://gotdotnet.com/exslt/dates-and-times">
    <xsl:template match="/">
Average time interval is 
<xsl:value-of select="date2:avg(root/timespan)"/>.
    </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result>Average time interval is P60D.</result>
    </sample>
</function>

--- NEW FILE: GDNDatesAndTimes-day-name.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="day-name" namespace="http://gotdotnet.com/exslt/dates-and-times" prefix="date2">
    <syntax>
        <return>string</return>
        <params>
            <param optional="yes">string</param>
            <param>string</param>
        </params>
    </syntax>
    <description>
        <p>The <tt>date2:day-name</tt> function is I18N extension of 
        the <a href="http://exslt.org/date/functions/day-name/index.html"><tt>date:day-name</tt></a> function.<br/>        
        Second non-optional argument is valid according to RFC 1766 culture name 
        (supported by <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemGlobalizationCultureInfoClassTopic.asp">System.Globalization.CultureInfo</a> class 
        of .NET framework) in "&lt;languagecode2&gt;-&lt;country/regioncode2&gt;" format, e.g. 
        "en-US" or "he-IL".
        </p>
    </description>
    <sample>
        <source><![CDATA[
<root>
    <date>2004-09-01</date>
</root>]]></source>
        <stylesheet><![CDATA[
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:date2="http://gotdotnet.com/exslt/dates-and-times" exclude-result-prefixes="date2">   
  <xsl:template match="root">
Day name in Russian: <xsl:value-of select="date2:day-name(date, 'ru-RU')"/>
  </xsl:template>
</xsl:stylesheet>]]></stylesheet>
        <result>Day name in Russian: среда</result>
    </sample>
</function>


--- NEW FILE: GDNMath-avg.xml ---
<?xml-stylesheet type="text/xsl" href="GDNFunctions.xsl"?>
<function name="avg" namespace="http://gotdotnet.com/exslt/math" prefix="math2">
    <syntax>
        <return>number</return>
        <params>
            <param>node-set</param>
        </params>
    </syntax>
    <description>
        <p>The <tt>math2:avg</tt> function returns average value of the nodes passed as the argument.</p>
        <p> If the node set is empty, or if the result of converting the string values of any of the nodes to a number is NaN, then NaN is returned.</p>
    </description>
    <sample>
        <source><![CDATA[<values>
    <value>7</value>
    <value>11</value>
    <value>8</value>
    <value>4</value>
</values>
]]></source>
        <stylesheet><![CDATA[<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:math2="http://gotdotnet.com/exslt/math" 
exclude-result-prefixes="math2">
    <xsl:template match="/">
        <avg>
 Average value: <xsl:value-of select="math2:avg(values/value)"/>.
        </avg>
    </xsl:template>
</xsl:stylesheet>
]]></stylesheet>
        <result> Average value: 7.5.</result>
    </sample>
</function>


--- NEW FILE: GDNFunctions.xsl ---
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:template match="function">
        <html>
            <head>
                <title>EXSLT.NET. Additional extenstion functions: <xsl:value-of select="concat(@prefix,':', @name)"/>
                </title>
            </head>
            <body>
                <h2>EXSLT.NET. Additional extenstion functions: <xsl:value-of select="concat(@prefix,':', @name)"/>
                </h2>
                <p>
                    <b>Namespace: </b>
                    <xsl:value-of select="@namespace"/>
                </p>
                <xsl:apply-templates select="syntax"/>
                <xsl:copy-of select="description"/>
                <xsl:apply-templates select="sample"/>
            </body>
        </html>
    </xsl:template>
    <xsl:template match="syntax">
        <h3>Function Syntax</h3>
        <p>
            <i>
                <xsl:value-of select="return"/>
            </i>&#xA0;<xsl:value-of select="../@prefix"/>:<xsl:value-of select="../@name"/>&#xA0;(<xsl:for-each select="params/param">
                <i>
                    <xsl:value-of select="."/>
                    <xsl:if test="@optional='yes'">?</xsl:if>
                    <xsl:if test="position() != last()">,&#xA0;</xsl:if>
                </i>
            </xsl:for-each>)</p>
    </xsl:template>
    <xsl:template match="sample">
        <h3>Example:</h3>
        <xsl:apply-templates/>
    </xsl:template>
    <xsl:template match="source">
        <h4>Source XML document:</h4>
        <pre><xsl:value-of select="."/></pre>
    </xsl:template>
    <xsl:template match="stylesheet">
        <h4>Stylesheet:</h4>
        <pre><xsl:value-of select="."/></pre>
    </xsl:template>
    <xsl:template match="result">
        <h4>Result:</h4>
        <pre><xsl:value-of select="."/></pre>
    </xsl:template>
</xsl:stylesheet>

--- NEW FILE: Functions.htm ---
<html>
  <head>
    <META http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
    <title>EXSLTNET 
                1.2 Function List</title>
    <style type="text/css">
                    body { font-family: Verdana, Arial, helvetica;}
                    .module-table {
                        width: 100%;
                    }                    
                </style>
  </head>
  <body>
    <h2>EXSLT.NET 1.2 Function List</h2>
    <hr>
    <div>EXSLT Modules:</div>
    <ol>
      <li>
        <a href="#Dates and Times">Dates and Times</a>
      </li>
      <li>
        <a href="#Common">Common</a>
      </li>
      <li>
        <a href="#Math">Math</a>
      </li>
      <li>
        <a href="#Random">Random</a>
      </li>
      <li>
        <a href="#Regular Expressions">Regular Expressions</a>
      </li>
      <li>
        <a href="#Sets">Sets</a>
      </li>
      <li>
        <a href="#Strings">Strings</a>
      </li>
    </ol>
    <div>Additional modules:</div>
    <ol>
      <li>
        <a href="#GotDotNet Dates and Times">GotDotNet Dates and Times</a>
      </li>
      <li>
        <a href="#GotDotNet Math">GotDotNet Math</a>
      </li>
      <li>
        <a href="#GotDotNet Regular Expressions">GotDotNet Regular Expressions</a>
      </li>
      <li>
        <a href="#GotDotNet Sets">GotDotNet Sets</a>
      </li>
      <li>
        <a href="#GotDotNet Strings">GotDotNet Strings</a>
      </li>
      <li>
        <a href="#GotDotNet Dynamic">GotDotNet Dynamic</a>
      </li>
    </ol>
    <hr>
    <p>
      <a name="Dates and Times">
        <div class="module-name">
          <b>Module:</b> Dates and Times</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://exslt.org/dates-and-times</div>
      <div class="module-homepage">
        <b>Homepage:</b> <a href="http://exslt.org/date/index.html">http://exslt.org/date/index.html</a></div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/format-date/index.html">date:format-date</a>
          </td>
          <td align="center">formatDate</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/parse-date/index.html">date:parse-date</a>
          </td>
          <td align="center">parseDate</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/date-time/index.html">date:date-time</a>
          </td>
          <td align="center">dateTime</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/date/index.html">date:date</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/time/index.html">date:time</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/year/index.html">date:year</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/leap-year/index.html">date:leap-year</a>
          </td>
          <td align="center">leapYear</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/month-in-year/index.html">date:month-in-year</a>
          </td>
          <td align="center">monthInYear</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/month-name/index.html">date:month-name</a>
          </td>
          <td align="center">monthName</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/month-abbreviation/index.html">date:month-abbreviation</a>
          </td>
          <td align="center">monthAbbreviation</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/week-in-year/index.html">date:week-in-year</a>
          </td>
          <td align="center">weekInYear</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/week-in-month/index.html">date:week-in-month</a>
          </td>
          <td align="center">weekInMonth</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/day-in-year/index.html">date:day-in-year</a>
          </td>
          <td align="center">dayInYear</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/day-in-month/index.html">date:day-in-month</a>
          </td>
          <td align="center">dayInMonth</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/day-of-week-in-month/index.html">date:day-of-week-in-month</a>
          </td>
          <td align="center">dayOfWeekInMonth</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/day-in-week/index.html">date:day-in-week</a>
          </td>
          <td align="center">dayInWeek</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/day-name/index.html">date:day-name</a>
          </td>
          <td align="center">dayName</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/day-abbreviation/index.html">date:day-abbreviation</a>
          </td>
          <td align="center">dayAbbreviation</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/hour-in-day/index.html">date:hour-in-day</a>
          </td>
          <td align="center">hourInDay</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/minute-in-hour/index.html">date:minute-in-hour</a>
          </td>
          <td align="center">minuteInHour</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/second-in-minute/index.html">date:second-in-minute</a>
          </td>
          <td align="center">secondInMinute</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/difference/index.html">date:difference</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/add/index.html">date:add</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/add-duration/index.html">date:add-duration</a>
          </td>
          <td align="center">addDuration</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/sum/index.html">date:sum</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/seconds/index.html">date:seconds</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/date/functions/duration/index.html">date:duration</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
      </table>
    </p>
    <hr>
    <p>
      <a name="Common">
        <div class="module-name">
          <b>Module:</b> Common</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://exslt.org/common</div>
      <div class="module-homepage">
        <b>Homepage:</b> <a href="http://exslt.org/exsl/index.html">http://exslt.org/exsl/index.html</a></div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/exsl/functions/node-set/index.html">exsl:node-set</a>
          </td>
          <td align="center">nodeSet</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/exsl/functions/object-type/index.html">exsl:object-type</a>
          </td>
          <td align="center">objectType</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
      </table>
    </p>
    <hr>
    <p>
      <a name="Math">
        <div class="module-name">
          <b>Module:</b> Math</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://exslt.org/math</div>
      <div class="module-homepage">
        <b>Homepage:</b> <a href="http://exslt.org/math/index.html">http://exslt.org/math/index.html</a></div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/min/index.html">math:min</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/max/index.html">math:max</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/highest/index.html">math:highest</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/lowest/index.html">math:lowest</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/abs/index.html">math:abs</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/sqrt/index.html">math:sqrt</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/power/index.html">math:power</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/constant/index.html">math:constant</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/log/index.html">math:log</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/random/index.html">math:random</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/sin/index.html">math:sin</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/cos/index.html">math:cos</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/tan/index.html">math:tan</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/asin/index.html">math:asin</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/acos/index.html">math:acos</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/atan/index.html">math:atan</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/atan2/index.html">math:atan2</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/math/functions/exp/index.html">math:exp</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
      </table>
    </p>
    <hr>
    <p>
      <a name="Random">
        <div class="module-name">
          <b>Module:</b> Random</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://exslt.org/random</div>
      <div class="module-homepage">
        <b>Homepage:</b> <a href="http://exslt.org/random/index.html">http://exslt.org/random/index.html</a></div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/random/functions/random-sequence/index.html">random:random-sequence</a>
          </td>
          <td align="center">randomSequence</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
      </table>
    </p>
    <hr>
    <p>
      <a name="Regular Expressions">
        <div class="module-name">
          <b>Module:</b> Regular Expressions</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://exslt.org/regular-expressions</div>
      <div class="module-homepage">
        <b>Homepage:</b> <a href="http://exslt.org/regexp/index.html">http://exslt.org/regexp/index.html</a></div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/regexp/functions/test/index.html">regexp:test</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/regexp/functions/match/index.html">regexp:match</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/regexp/functions/replace/index.html">regexp:replace</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
      </table>
    </p>
    <hr>
    <p>
      <a name="Sets">
        <div class="module-name">
          <b>Module:</b> Sets</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://exslt.org/sets</div>
      <div class="module-homepage">
        <b>Homepage:</b> <a href="http://exslt.org/set/index.html">http://exslt.org/set/index.html</a></div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/set/functions/difference/index.html">set:difference</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/set/functions/intersection/index.html">set:intersection</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/set/functions/distinct/index.html">set:distinct</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/set/functions/has-same-node/index.html">set:has-same-node</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/set/functions/leading/index.html">set:leading</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/set/functions/trailing/index.html">set:trailing</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
      </table>
    </p>
    <hr>
    <p>
      <a name="Strings">
        <div class="module-name">
          <b>Module:</b> Strings</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://exslt.org/strings</div>
      <div class="module-homepage">
        <b>Homepage:</b> <a href="http://exslt.org/str/index.html">http://exslt.org/str/index.html</a></div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/tokenize/index.html">str:tokenize</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/replace/index.html">str:replace</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/padding/index.html">str:padding</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/align/index.html">str:align</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/encode-uri/index.html">str:encode-uri</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/decode-uri/index.html">str:decode-uri</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/concat/index.html">str:concat</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
        <tr>
          <td>
            <a href="http://exslt.org/str/functions/split/index.html">str:split</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
      </table>
    </p>
    <hr>
    <p>
      <a name="GotDotNet Dates and Times">
        <div class="module-name">
          <b>Module:</b> GotDotNet Dates and Times</div>
      </a>
      <div class="module-ns">
        <b>Namespace:</b> http://gotdotnet.com/exslt/dates-and-times</div>
      <div class="note">
        <b>Note:</b> These functions are not part of EXSLT.</div>
      <table border="1" class="module-table">
        <tr>
          <th>Function name</th>
          <th>Alias</th>
          <th>Supported</th>
        </tr>
        <tr>
          <td>
            <a href="GDNDatesAndTimes-avg.xml">date2:avg</a>
          </td>
          <td align="center">-</td>
          <td align="center" style="color:green;">yes</td>
        </tr>
    ...
 
[truncated message content]

[mvp-xml-cvs] EXSLT/v1/lib changelog.txt,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/lib
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1/lib

Added Files:
	changelog.txt 
Log Message:


--- NEW FILE: changelog.txt ---
---------------------------------------------------------
July 19, 2005

Initial setup.
Will contain external libraries referenced by the project.

[mvp-xml-cvs] EXSLT/v1 .cvsignore,NONE,1.1 EXSLT.NET.sln,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29285/v1

Added Files:
	.cvsignore EXSLT.NET.sln 
Log Message:


--- NEW FILE: .cvsignore ---
bin
obj
*.user
*.suo
--- NEW FILE: EXSLT.NET.sln ---
Microsoft Visual Studio Solution File, Format Version 8.00
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MethodRenamer", "src\MethodRenamer\MethodRenamer.csproj", "{A22418E5-DCE6-4D12-A016-151EA614A787}"
	ProjectSection(ProjectDependencies) = postProject
	EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ExsltTest", "test\ExsltTest\ExsltTest.csproj", "{AC8B9015-E508-4E40-8E6D-C4FCF52CE4B0}"
	ProjectSection(ProjectDependencies) = postProject
	EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ExsltXPathTest", "test\ExsltXPathTest\ExsltXPathTest.csproj", "{705AA213-1D02-4CD2-9ED5-A7D9668C714D}"
	ProjectSection(ProjectDependencies) = postProject
	EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Exslt", "src\Exslt\Exslt.csproj", "{BA694D9F-6B1E-4038-AC81-BF1640C07D90}"
	ProjectSection(ProjectDependencies) = postProject
	EndProjectSection
EndProject
Global
	GlobalSection(SolutionConfiguration) = preSolution
		Debug = Debug
		Release = Release
	EndGlobalSection
	GlobalSection(ProjectConfiguration) = postSolution
		{A22418E5-DCE6-4D12-A016-151EA614A787}.Debug.ActiveCfg = Debug|.NET
		{A22418E5-DCE6-4D12-A016-151EA614A787}.Debug.Build.0 = Debug|.NET
		{A22418E5-DCE6-4D12-A016-151EA614A787}.Release.ActiveCfg = Release|.NET
		{A22418E5-DCE6-4D12-A016-151EA614A787}.Release.Build.0 = Release|.NET
		{AC8B9015-E508-4E40-8E6D-C4FCF52CE4B0}.Debug.ActiveCfg = Debug|.NET
		{AC8B9015-E508-4E40-8E6D-C4FCF52CE4B0}.Debug.Build.0 = Debug|.NET
		{AC8B9015-E508-4E40-8E6D-C4FCF52CE4B0}.Release.ActiveCfg = Release|.NET
		{AC8B9015-E508-4E40-8E6D-C4FCF52CE4B0}.Release.Build.0 = Release|.NET
		{705AA213-1D02-4CD2-9ED5-A7D9668C714D}.Debug.ActiveCfg = Debug|.NET
		{705AA213-1D02-4CD2-9ED5-A7D9668C714D}.Debug.Build.0 = Debug|.NET
		{705AA213-1D02-4CD2-9ED5-A7D9668C714D}.Release.ActiveCfg = Release|.NET
		{705AA213-1D02-4CD2-9ED5-A7D9668C714D}.Release.Build.0 = Release|.NET
		{BA694D9F-6B1E-4038-AC81-BF1640C07D90}.Debug.ActiveCfg = Debug|.NET
		{BA694D9F-6B1E-4038-AC81-BF1640C07D90}.Debug.Build.0 = Debug|.NET
		{BA694D9F-6B1E-4038-AC81-BF1640C07D90}.Release.ActiveCfg = Release|.NET
		{BA694D9F-6B1E-4038-AC81-BF1640C07D90}.Release.Build.0 = Release|.NET
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
	EndGlobalSection
	GlobalSection(ExtensibilityAddIns) = postSolution
	EndGlobalSection
EndGlobal

[mvp-xml-cvs] EXSLT/v1/test/ExsltXPathTest/obj/Debug/TempPE - New directory

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltXPathTest/obj/Debug/TempPE
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv28222/TempPE

Log Message:
Directory /cvsroot/mvp-xml/EXSLT/v1/test/ExsltXPathTest/obj/Debug/TempPE added to the repository

[mvp-xml-cvs] EXSLT/v1/test/ExsltXPathTest/obj/Debug/temp - New directory

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltXPathTest/obj/Debug/temp
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv28222/temp

Log Message:
Directory /cvsroot/mvp-xml/EXSLT/v1/test/ExsltXPathTest/obj/Debug/temp added to the repository

[mvp-xml-cvs] EXSLT/v1/test/ExsltXPathTest/obj/Debug - New directory

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/EXSLT/v1/test/ExsltXPathTest/obj/Debug
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv28167/Debug

Log Message:
Directory /cvsroot/mvp-xml/EXSLT/v1/test/ExsltXPathTest/obj/Debug added to the repository