internal XPathResult(XPathNodeIterator nodeSetResult)
     : this()
 {
     this.nodeSetResult = nodeSetResult;
     this.internalIterator = nodeSetResult as SafeNodeSequenceIterator;
     this.resultType = XPathResultType.NodeSet;
 }

            public override IXsltContextFunction ResolveFunction(string prefix, string name, XPathResultType[] argTypes)
            {
                if (string.IsNullOrEmpty(prefix))
                   return base.ResolveFunction(prefix, name, argTypes);

                return mvpContext.ResolveFunction(prefix, name, argTypes);
            }

 public override void SetXsltContext(XsltContext context)
 {
     if (context == null)
     {
         throw XPathException.Create(SR.Xp_NoContext);
     }
     if (this.xsltContext != context)
     {
         xsltContext = context;
         foreach (Query argument in _args)
         {
             argument.SetXsltContext(context);
         }
         XPathResultType[] argTypes = new XPathResultType[_args.Count];
         for (int i = 0; i < _args.Count; i++)
         {
             argTypes[i] = _args[i].StaticType;
         }
         _function = xsltContext.ResolveFunction(prefix, name, argTypes);
         // KB article allows to return null, see http://support.microsoft.com/?kbid=324462#6
         if (_function == null)
         {
             throw XPathException.Create(SR.Xp_UndefFunc, QName);
         }
     }
 }

 private void CheckNodeSet(XPathResultType t)
 {
     if ((t != XPathResultType.NodeSet) && (t != XPathResultType.Any))
     {
         throw XPathException.Create("Xp_NodeSetExpected", this.scanner.SourceText);
     }
 }

        /// <summary>
        /// Creates a new extension function definition.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="minArgs"></param>
        /// <param name="maxArgs"></param>
        /// <param name="argTypes"></param>
        /// <param name="returnType"></param>
        /// <param name="fn"></param>
        public TriflesXPathExtensionFunction(XName name, int minArgs, int maxArgs, XPathResultType[] argTypes, XPathResultType returnType, TriflesXPathInvokable fn)
        {
            FunctionName = Checker.NotNull(name, "name");

            Minargs = minArgs;
            Maxargs = maxArgs;

            if (Minargs < 0)
            {
                throw new ArgumentOutOfRangeException("minArgs");
            }
            else if (Maxargs < Minargs)
            {
                throw new ArgumentOutOfRangeException("maxArgs", "maxArgs cannot be less than minArgs");
            }

            if (argTypes == null)
            {
                argTypes = new XPathResultType[0];
            }

            this.argTypes = argTypes.ToImmutableArray();

            ReturnType = Checker.NotNull(returnType, "returnType");

            invokable = Checker.NotNull(fn, "fn");
        }

 public override IXsltContextFunction ResolveFunction(string prefix, string name, XPathResultType[] argTypes)
 {
   XsltFunction function;
   if (functions.TryGetValue(name, out function))
     return function;
   return baseContext.ResolveFunction(prefix, name, argTypes);
 }

 protected XPathMessageFunction(XPathResultType[] argTypes, int max, int min, XPathResultType retType)
 {
     this.argTypes = argTypes;
     this.maxArgs = max;
     this.minArgs = min;
     this.retType = retType;
 }

		protected void Init (int minArgs, int maxArgs, XPathResultType returnType, XPathResultType[] argTypes)
		{
			this.minargs	= minArgs;
			this.maxargs	= maxArgs;
			this.returnType = returnType;
			this.argTypes	= argTypes;
		}

		public ExsltContextFunction(MethodInfo mi, XPathResultType[] argTypes,
			object owner)
		{
			_method = mi;
			_argTypes = argTypes;
			_ownerObj = owner;
		}

 public CustomXsltFunction(string name, XPathResultType[] argTypes, XPathResultType returnType, InvokedFunction function = null)
 {
     Prefix = String.Empty;
     Name = name;
     ArgTypes = argTypes;
     ReturnType = returnType;
     Function = function;
 }

            public override IXsltContextFunction ResolveFunction(string prefix, string name, XPathResultType[] argTypes)
            {
                IXsltContextFunction function = null;
                if (string.IsNullOrEmpty(prefix))
                    functions.TryGetValue(name, out function);

                return function ?? base.ResolveFunction(prefix, name, argTypes);
            }

 public override IXsltContextFunction ResolveFunction(string prefix, string name, XPathResultType[] ArgTypes)
 {
     if (name == "upper-case")
     {
         return new UpperCase();
     }
     return null;
 }

        public override IXsltContextFunction ResolveFunction(string prefix, string name, XPathResultType[] ArgTypes)
        {
            var func = _functions.SingleOrDefault(f => f.Name == name && f.Prefix == prefix);

            if(func != null)
                return func;
            else
                throw new InvalidOperationException("Unknown function in XPath: " + name);              
        }

        public override IXsltContextFunction ResolveFunction(string prefix, string name, XPathResultType[] argTypes)
        {
            if (name == "document")
            {
                return new XsltContextFunction("document");
            }

            return null;
        }

        /// <summary>
        /// Creates the variable object.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <param name="isLocal"></param>
        /// <param name="isParam"></param>
        /// <param name="resultType"></param>
        public TriflesXPathExtensionVariable(XName name, object value, bool isLocal = false, bool isParam = false, XPathResultType? resultType = null)
        {
            this.VariableName = name;
            this.Value = value;
            this.IsLocal = isLocal;
            this.IsParam = isParam;

            this.VariableType = resultType.HasValue ? resultType.Value : TriflesXPathData.GuessXPathResultType(value);
        }

        public override IXsltContextFunction ResolveFunction(string prefix, string name, XPathResultType[] ArgTypes) {
            switch (name) {
                case "match":
                    return m_MatchFct;
                case "canCastTo":
                    return m_CanCastTo;
                default:
                    throw new NotSupportedException();
            }
		}

            public override IXsltContextFunction ResolveFunction(string prefix, string name, XPathResultType[] argTypes)
            {
                if (string.IsNullOrEmpty(prefix))
                {
                   if (name == "current" && argTypes.Length == 0)
                  return currentFunction;
                }

                return base.ResolveFunction(prefix, name, argTypes);
            }

 // Constructors
 
 public XsltFunction(string name, XPathResultType[] argTypes, XPathResultType returnType,
   Func<XsltContext, XPathNavigator, object[], object> implementation, int? minArgs = null, int? maxArgs = null)
 {
   this.name = name;
   this.argTypes = argTypes;
   this.returnType = returnType;
   this.minArgs = minArgs ?? argTypes.Length;
   this.maxArgs = maxArgs ?? argTypes.Length;
   this.implementation = implementation;
 }

 static XPathParser()
 {
     XPathResultType[] typeArray5 = new XPathResultType[3];
     typeArray5[0] = XPathResultType.String;
     temparray6 = typeArray5;
     temparray7 = new XPathResultType[] { XPathResultType.String, XPathResultType.String, XPathResultType.String };
     temparray8 = new XPathResultType[] { XPathResultType.Boolean };
     temparray9 = new XPathResultType[1];
     functionTable = CreateFunctionTable();
     AxesTable = CreateAxesTable();
 }

        public override IXsltContextFunction ResolveFunction(string prefix, string name,
                                                             XPathResultType[] argTypes)
        {
            IXsltContextFunction function = null;

            if (this.functions.TryGetValue(prefix + ":" + name, out function))
            {
                return function;
            }

            return null;
        }