//------------------------------------------------------------------------------
// <copyright file="QilGenerator.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
// <owner current="true" primary="true">Microsoft</owner>
// <spec>http://www.w3.org/TR/xslt.html</spec>
// <spec>http://www.w3.org/TR/xslt20/</spec>
//------------------------------------------------------------------------------

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Reflection;
using System.Text;
using System.Xml.Xsl.Qil;
using System.Xml.Xsl.Runtime;
using System.Xml.Xsl.XPath;

namespace System.Xml.Xsl.Xslt {
    using Res           = System.Xml.Utils.Res;
    using ScopeRecord   = CompilerScopeManager<QilIterator>.ScopeRecord;
    using T             = XmlQueryTypeFactory;

    // Everywhere in this code in case of error in the stylesheet we should call ReportError or ReportWarning

    internal class ReferenceReplacer : QilReplaceVisitor {
        private QilReference lookFor, replaceBy;

        public ReferenceReplacer(QilFactory f) : base(f) {
        }

        public QilNode Replace(QilNode expr, QilReference lookFor, QilReference replaceBy) {
            QilDepthChecker.Check(expr);
            this.lookFor = lookFor;
            this.replaceBy = replaceBy;
            return VisitAssumeReference(expr);
        }

        protected override QilNode VisitReference(QilNode n) {
            return (n == lookFor) ? replaceBy : n;
        }
    }

    internal partial class QilGenerator : IErrorHelper {
        private CompilerScopeManager<QilIterator> scope;
        private OutputScopeManager      outputScope;
        private HybridDictionary        prefixesInUse;

        private XsltQilFactory          f;
        private XPathBuilder            xpathBuilder;
        private XPathParser<QilNode>    xpathParser;
        private XPathPatternBuilder     ptrnBuilder;
        private XPathPatternParser      ptrnParser;
        private ReferenceReplacer       refReplacer;
        private KeyMatchBuilder         keyMatchBuilder;
        private InvokeGenerator         invkGen;
        private MatcherBuilder          matcherBuilder;
        private QilStrConcatenator      strConcat;
        private VariableHelper          varHelper;

        private Compiler        compiler;
        private QilList         functions;
        private QilFunction     generalKey;
        private bool            formatNumberDynamicUsed;
        private QilList         extPars;
        private QilList         gloVars;
        private QilList         nsVars;

        private XmlQueryType    elementOrDocumentType;
        private XmlQueryType    textOrAttributeType;
        private XslNode         lastScope;
        private XslVersion      xslVersion;

        private QilName         nameCurrent;
        private QilName         namePosition;
        private QilName         nameLast;
        private QilName         nameNamespaces;
        private QilName         nameInit;

        private SingletonFocus  singlFocus;
        private FunctionFocus   funcFocus;
        private LoopFocus       curLoop;

        private int             formatterCnt;

        public static QilExpression CompileStylesheet(Compiler compiler) {
            return new QilGenerator(compiler.IsDebug).Compile(compiler);
        }

        private QilGenerator(bool debug) {
            scope           = new CompilerScopeManager<QilIterator>();
            outputScope     = new OutputScopeManager();
            prefixesInUse   = new HybridDictionary();
            f               = new XsltQilFactory(new QilFactory(), debug);
            xpathBuilder    = new XPathBuilder((IXPathEnvironment) this);
            xpathParser     = new XPathParser<QilNode>();
            ptrnBuilder     = new XPathPatternBuilder((IXPathEnvironment) this);
            ptrnParser      = new XPathPatternParser();
            refReplacer     = new ReferenceReplacer(f.BaseFactory);
            invkGen         = new InvokeGenerator(f, debug);
            matcherBuilder  = new MatcherBuilder(f, refReplacer, invkGen);
            singlFocus      = new SingletonFocus(f);
            funcFocus       = new FunctionFocus();
            curLoop         = new LoopFocus(f);
            strConcat       = new QilStrConcatenator(f);
            varHelper       = new VariableHelper(f);

            elementOrDocumentType = T.DocumentOrElement;
            textOrAttributeType   = T.NodeChoice(XmlNodeKindFlags.Text | XmlNodeKindFlags.Attribute);

            nameCurrent     = f.QName("current"   , XmlReservedNs.NsXslDebug);
            namePosition    = f.QName("position"  , XmlReservedNs.NsXslDebug);
            nameLast        = f.QName("last"      , XmlReservedNs.NsXslDebug);
            nameNamespaces  = f.QName("namespaces", XmlReservedNs.NsXslDebug);
            nameInit        = f.QName("init"      , XmlReservedNs.NsXslDebug);

            formatterCnt    = 0;
        }

        private bool IsDebug {
            get { return compiler.IsDebug; }
        }

        private bool EvaluateFuncCalls  { get { return !IsDebug; } }
        private bool InferXPathTypes    { get { return !IsDebug; } }

        private QilExpression Compile(Compiler compiler) {
            Debug.Assert(compiler != null);
            this.compiler   = compiler;
            this.functions  = f.FunctionList();
            this.extPars    = f.GlobalParameterList();
            this.gloVars    = f.GlobalVariableList();
            this.nsVars     = f.GlobalVariableList();

            compiler.Scripts.CompileScripts();

            // Refactor huge templates into smaller ones (more JIT friendly)
            (new XslAstRewriter()).Rewrite(compiler);

            if (!IsDebug) {
                (new XslAstAnalyzer()).Analyze(compiler);
            }

            // Global variables and external params are visible from everywhere, so we have
            // to prepopulate the scope with all of them before starting compilation
            CreateGlobalVarPars();

            try {
                CompileKeys();
                CompileAndSortMatches(compiler.Root.Imports[0]);
                PrecompileProtoTemplatesHeaders();
                CompileGlobalVariables();

                foreach (ProtoTemplate tmpl in compiler.AllTemplates) {
                    CompileProtoTemplate(tmpl);
                }
                varHelper.CheckEmpty();
            }
            catch (XslLoadException e) {
                e.SetSourceLineInfo(lastScope.SourceLine);
                throw;
            }
            catch (Exception e) {
                if (!XmlException.IsCatchableException(e)) {
                    throw;
                }
                throw new XslLoadException(e, lastScope.SourceLine);
            }

            CompileInitializationCode();
            QilNode root = CompileRootExpression(compiler.StartApplyTemplates);

            // Clean default values which we calculate in caller context
            foreach (ProtoTemplate tmpl in compiler.AllTemplates) {
                foreach (QilParameter par in tmpl.Function.Arguments) {
                    if (!IsDebug || par.Name.Equals(nameNamespaces)) {
                        par.DefaultValue = null;
                    }
                }
            }

            // Create list of all early bound objects
            Dictionary<string, Type> scriptClasses = compiler.Scripts.ScriptClasses;
            List<EarlyBoundInfo> ebTypes = new List<EarlyBoundInfo>(scriptClasses.Count);
            foreach (KeyValuePair<string, Type> pair in scriptClasses) {
                if (pair.Value != null) {
                    ebTypes.Add(new EarlyBoundInfo(pair.Key, pair.Value));
                }
            }

            QilExpression qil = f.QilExpression(root, f.BaseFactory); {
                qil.EarlyBoundTypes       = ebTypes;
                qil.FunctionList          = functions;
                qil.GlobalParameterList   = extPars;
                qil.GlobalVariableList    = gloVars;
                qil.WhitespaceRules       = compiler.WhitespaceRules;
                qil.IsDebug               = IsDebug;
                qil.DefaultWriterSettings = compiler.Output.Settings;
            }

            QilDepthChecker.Check(qil);

            return qil;
        }

        private QilNode InvokeOnCurrentNodeChanged() {
            Debug.Assert(IsDebug && curLoop.IsFocusSet);
            QilIterator i;
            return f.Loop(i = f.Let(f.InvokeOnCurrentNodeChanged(curLoop.GetCurrent())), f.Sequence());
        }

        [Conditional("DEBUG")]
        private void CheckSingletonFocus() {
            Debug.Assert(!curLoop.IsFocusSet && !funcFocus.IsFocusSet, "Must be compiled using singleton focus");
        }

        private void CompileInitializationCode() {
            // Initialization code should be executed before any other code (global variables/parameters or root expression)
            // For this purpose we insert it as THE FIRST global variable $init (global variables are calculated before global parameters)
            // and put all initalization code in it.
            // In retail mode global variables are calculated lasely if they don't have side effects. 
            // To mark $init as variable with side effect we put all code to function and set SideEffect flag on this function.
            // ILGen expects that all library functions are sideeffect free. To prevent calls to RegisterDecimalFormat() to be optimized out 
            // we add results returned from these calls and return them as a result of initialization function.
            QilNode init = f.Int32(0);

            // Register all decimal formats, they are needed for format-number()
            if (formatNumberDynamicUsed || IsDebug) {
                bool defaultDefined = false;
                foreach (DecimalFormatDecl format in compiler.DecimalFormats) {
                    init = f.Add(init, f.InvokeRegisterDecimalFormat(format));
                    defaultDefined |= (format.Name == DecimalFormatDecl.Default.Name);
                }
                if (!defaultDefined) {
                    init = f.Add(init, f.InvokeRegisterDecimalFormat(DecimalFormatDecl.Default));
                }
            }

            // Register all script namespaces
            foreach (string scriptNs in compiler.Scripts.ScriptClasses.Keys) {
                init = f.Add(init, f.InvokeCheckScriptNamespace(scriptNs));
            }

            if (init.NodeType == QilNodeType.Add) {
                QilFunction initFunction = f.Function(f.FormalParameterList(), init, /*sideEffects:*/f.True());
                initFunction.DebugName = "Init";
                this.functions.Add(initFunction);

                QilNode initBinding = f.Invoke(initFunction, f.ActualParameterList());
                if (IsDebug) {
                    // In debug mode all variables must have type item*
                    initBinding = f.TypeAssert(initBinding, T.ItemS);
                }
                QilIterator initVar = f.Let(initBinding);
                initVar.DebugName = nameInit.ToString();
                gloVars.Insert(0, initVar);
            }
        }

        private QilNode CompileRootExpression(XslNode applyTmpls) {
            // Compile start apply-templates call
            CheckSingletonFocus();
            singlFocus.SetFocus(SingletonFocusType.InitialContextNode);
            QilNode result = GenerateApply(compiler.Root, applyTmpls);
            singlFocus.SetFocus(null);

            return f.DocumentCtor(result);
        }

        private QilList EnterScope(XslNode node) {
            // This is the only place where lastScope is changed
            lastScope = node;
            xslVersion = node.XslVersion;
            if (this.scope.EnterScope(node.Namespaces)) {
                return BuildDebuggerNamespaces();
            }
            return null;
        }

        private void ExitScope() {
            this.scope.ExitScope();
        }

        private QilList BuildDebuggerNamespaces() {
            if (IsDebug) {
                QilList nsDecls = f.BaseFactory.Sequence();
                foreach (ScopeRecord rec in this.scope) {
                    nsDecls.Add(f.NamespaceDecl(f.String(rec.ncName), f.String(rec.nsUri)));
                }
                return nsDecls;
            }
            return null;
        }

        // For each call instruction - call-template, use-attribute-sets, apply-template, apply-imports - we have
        // to pass the current execution context which may be represented as three additional implicit arguments:
        // current, position, last.  In most cases the last two ones are never used, so for the purpose
        // of optimization in non-debug mode we bind them only if they are actually needed.

        // Strictly speaking, a (proto)template function is supplied with the additional position argument if both
        // the following conditions are true:
        //   1. At least one template within the given stylesheet contains a "----" position() function invocation
        //      (needPositionArgs == true).  ---- here means "not within any of for-each instructions".
        //   2. THIS template contains a ---- position() invocation or a ---- call-template, use-attribute-sets,
        //      or apply-imports instruction.  Note: apply-template's are not taken into account because in that
        //      case the call will be actually wrapped in a tuple.
        //
        // The same is true for additional last arguments.

        // There are 3 cases when context methods may be called:
        // 1. In context of for-each expression
        // 2. In context of template
        // 3. In context of global variable
        // We treating this methods differentely when they are called to create implicit arguments.
        // Implicite argument (position, last) are rare and lead to uneficiant code. So we treating them
        // specialy to be able eliminate them later, wen we compiled everithing and can detect was they used or not.

        // Returns context node
        private QilNode GetCurrentNode() {
            if (curLoop.IsFocusSet) {
                return curLoop.GetCurrent();
            } else if (funcFocus.IsFocusSet) {
                return funcFocus.GetCurrent();
            } else {
                return singlFocus.GetCurrent();
            }
        }

        // Returns context position
        private QilNode GetCurrentPosition() {
            if (curLoop.IsFocusSet) {
                return curLoop.GetPosition();
            } else if (funcFocus.IsFocusSet) {
                return funcFocus.GetPosition();
            } else {
                return singlFocus.GetPosition();
            }
        }

        // Returns context size
        private QilNode GetLastPosition() {
            if (curLoop.IsFocusSet) {
                return curLoop.GetLast();
            } else if (funcFocus.IsFocusSet) {
                return funcFocus.GetLast();
            } else {
                return singlFocus.GetLast();
            }
        }

        private XmlQueryType ChooseBestType(VarPar var) {
            if (IsDebug || !InferXPathTypes) {
                return T.ItemS;
            }

            switch (var.Flags & XslFlags.TypeFilter) {
            case XslFlags.String  : return T.StringX;;
            case XslFlags.Number  : return T.DoubleX;
            case XslFlags.Boolean : return T.BooleanX;
            case XslFlags.Node    : return T.NodeNotRtf;
            case XslFlags.Nodeset : return T.NodeNotRtfS;
            case XslFlags.Rtf     : return T.Node;
            case XslFlags.Node    | XslFlags.Rtf     : return T.Node;
            case XslFlags.Node    | XslFlags.Nodeset : return T.NodeNotRtfS;
            case XslFlags.Nodeset | XslFlags.Rtf     : return T.NodeS;
            case XslFlags.Node    | XslFlags.Nodeset | XslFlags.Rtf : return T.NodeS;
            default               : return T.ItemS;
            }
        }

        // In debugger we need to pass to each (almost) template $namespace parameter with list of namespaces that
        // are defined on stylesheet and this template. In most cases this will be only xmlns:xsl="..."
        // To prevent creating these list with each call-template/apply-template we create one global variable for each unique set of namespaces
        // This function looks through list of existent global variables for suitable ns list and add one if none was found.
        private QilIterator GetNsVar(QilList nsList) {
            Debug.Assert(IsDebug, "This is debug only logic");
            // All global vars at this point are nsList like one we are looking now.
            foreach (QilIterator var in this.nsVars) {
                Debug.Assert(var.XmlType.IsSubtypeOf(T.NamespaceS));
                Debug.Assert(var.Binding is QilList);
                QilList varList = (QilList)var.Binding;
                if (varList.Count != nsList.Count) {
                    continue;
                }
                bool found = true;
                for (int i = 0; i < nsList.Count; i ++) {
                    Debug.Assert(nsList[i].NodeType  == QilNodeType.NamespaceDecl);
                    Debug.Assert(varList[i].NodeType == QilNodeType.NamespaceDecl);
                    if (
                        ((QilLiteral)((QilBinary)nsList[i]).Right).Value != ((QilLiteral)((QilBinary)varList[i]).Right).Value ||
                        ((QilLiteral)((QilBinary)nsList[i]).Left ).Value != ((QilLiteral)((QilBinary)varList[i]).Left ).Value
                    ) {
                        found = false;
                        break;
                    }
                }
                if (found) {
                    return var;  // Found!
                }
            }
            QilIterator newVar = f.Let(nsList);
            newVar.DebugName = f.QName("ns" + this.nsVars.Count, XmlReservedNs.NsXslDebug).ToString();
            this.gloVars.Add(newVar);
            this.nsVars.Add(newVar);
            return newVar;
        }

        private void PrecompileProtoTemplatesHeaders() {
            // All global variables should be in scoupe here.
            List<VarPar>                     paramWithCalls  = null;
            Dictionary<VarPar, Template   >  paramToTemplate = null;
            Dictionary<VarPar, QilFunction>  paramToFunction = null;

            foreach (ProtoTemplate tmpl in compiler.AllTemplates) {
                Debug.Assert(tmpl != null && tmpl.Function == null);
                Debug.Assert(tmpl.NodeType == XslNodeType.AttributeSet || tmpl.NodeType == XslNodeType.Template);
                QilList args = f.FormalParameterList();
                XslFlags flags = !IsDebug ? tmpl.Flags : XslFlags.FullFocus;

                QilList nsList = EnterScope(tmpl);
                if ((flags & XslFlags.Current) != 0) {
                    args.Add(CreateXslParam(CloneName(nameCurrent), T.NodeNotRtf));
                }
                if ((flags & XslFlags.Position) != 0) {
                    args.Add(CreateXslParam(CloneName(namePosition), T.DoubleX));
                }
                if ((flags & XslFlags.Last) != 0) {
                    args.Add(CreateXslParam(CloneName(nameLast), T.DoubleX));
                }
                if (IsDebug && nsList != null) {
                    // AttributeSet doesn't need this logic because: 1) it doesn't have args; 2) we merge them.
                    // SimplifiedStylesheet has nsList == null as well.
                    QilParameter ns = CreateXslParam(CloneName(nameNamespaces), T.NamespaceS);
                    ns.DefaultValue = GetNsVar(nsList);
                    args.Add(ns);
                }

                Template template = tmpl as Template;
                if (template != null) {
                    Debug.Assert(tmpl.NodeType == XslNodeType.Template);

                    CheckSingletonFocus();
                    funcFocus.StartFocus(args, flags);
                    for (int i = 0; i < tmpl.Content.Count; i++) {
                        XslNode node = tmpl.Content[i];
                        if (node.NodeType == XslNodeType.Text) {
                            // NOTE: We should take care of a bizarre case when xsl:param comes after TextCtor:
                            // <xsl:template match="/" xml:space="preserve">  <xsl:param name="par"/>
                            continue;
                        }
                        if (node.NodeType == XslNodeType.Param) {
                            VarPar xslPar = (VarPar)node;
                            EnterScope(xslPar);
                            if (scope.IsLocalVariable(xslPar.Name.LocalName, xslPar.Name.NamespaceUri)) {
                                ReportError(/*[XT0580]*/Res.Xslt_DupLocalVariable, xslPar.Name.QualifiedName);
                            }
                            QilParameter param = CreateXslParam(xslPar.Name, ChooseBestType(xslPar));
                            if (IsDebug) {
                                param.Annotation = xslPar;
                                // Actual compilation will happen in CompileProtoTemplate()
                            } else {
                                if ((xslPar.DefValueFlags & XslFlags.HasCalls) == 0) {
                                    param.DefaultValue = CompileVarParValue(xslPar);
                                } else {
                                    // We can't compile param default value here because it contains xsl:call-template and
                                    // we will not be able to compile any calls befor we finish with all headers
                                    // So we compile this default value as a call to helper function. Now we create header for this function
                                    // and preserve this param in paramWithCall list. Later in this function we finaly compile all preserved
                                    // parameters and set resulted default values as helper function definition.
                                    QilList paramFormal = f.FormalParameterList();
                                    QilList paramActual = f.ActualParameterList();
                                    for (int j = 0; j < args.Count; j ++) {
                                        QilParameter formal = f.Parameter(args[j].XmlType); {
                                            formal.DebugName = ((QilParameter) args[j]).DebugName;
                                            formal.Name = CloneName(((QilParameter)args[j]).Name);
                                            SetLineInfo(formal, args[j].SourceLine);
                                        }
                                        paramFormal.Add(formal);
                                        paramActual.Add(args[j]);
                                    }
                                    // Param doesn't know what implicit args it needs, so we pass all implicit args that was passed to its template.
                                    // let's reflect this fact in parans FocusFlags:
                                    xslPar.Flags |= (template.Flags & XslFlags.FocusFilter);
                                    QilFunction paramFunc = f.Function(paramFormal,
                                        f.Boolean((xslPar.DefValueFlags & XslFlags.SideEffects) != 0),
                                        ChooseBestType(xslPar)
                                    );
                                    paramFunc.SourceLine = SourceLineInfo.NoSource;
                                    paramFunc.DebugName = "<xsl:param name=\"" + xslPar.Name.QualifiedName + "\">";
                                    param.DefaultValue = f.Invoke(paramFunc, paramActual);
                                    // store VarPar here to compile it on next pass:
                                    if (paramWithCalls == null) {
                                        paramWithCalls  = new List<VarPar>();
                                        paramToTemplate = new Dictionary<VarPar, Template>();
                                        paramToFunction = new Dictionary<VarPar, QilFunction>();
                                    }
                                    paramWithCalls.Add(xslPar);
                                    paramToTemplate.Add(xslPar, template );
                                    paramToFunction.Add(xslPar, paramFunc);
                                }
                            }
                            SetLineInfo(param, xslPar.SourceLine);
                            ExitScope();
                            scope.AddVariable(xslPar.Name, param);
                            args.Add(param);
                        } else {
                            break;
                        }
                    }
                    funcFocus.StopFocus();
                }
                ExitScope();

                tmpl.Function = f.Function(args,
                    f.Boolean((tmpl.Flags & XslFlags.SideEffects) != 0),
                    tmpl is AttributeSet ? T.AttributeS : T.NodeNotRtfS
                );
                tmpl.Function.DebugName = tmpl.GetDebugName();
                Debug.Assert((template != null) == (tmpl.SourceLine != null), "Templates must have line information, and attribute sets must not");
                SetLineInfo(tmpl.Function, tmpl.SourceLine ?? SourceLineInfo.NoSource);
                this.functions.Add(tmpl.Function);
            } // foreach (ProtoTemplate tmpl in compiler.AllTemplates)

            // Finish compiling postponed parameters (those having calls in their default values)
            if (paramWithCalls != null) {
                Debug.Assert(! IsDebug, "In debug mode we don't generate parumWithCalls functions. Otherwise focus flags should be adjusted");
                foreach (VarPar par in paramWithCalls) {
                    Template    tmpl = paramToTemplate[par];
                    QilFunction func = paramToFunction[par];
                    CheckSingletonFocus();
                    funcFocus.StartFocus(func.Arguments, par.Flags);
                    EnterScope(tmpl);
                    EnterScope(par);
                    foreach (QilParameter arg in func.Arguments) {
                        scope.AddVariable(arg.Name, arg);
                    }
                    func.Definition = CompileVarParValue(par);
                    SetLineInfo(func.Definition, par.SourceLine);
                    ExitScope();
                    ExitScope();
                    funcFocus.StopFocus();
                    this.functions.Add(func);
                }
            }
        }

        private QilParameter CreateXslParam(QilName name, XmlQueryType xt) {
            QilParameter arg = f.Parameter(xt);
            arg.DebugName = name.ToString();
            arg.Name = name;
            return arg;
        }

        private void CompileProtoTemplate(ProtoTemplate tmpl) {
            Debug.Assert(tmpl != null && tmpl.Function != null && tmpl.Function.Definition.NodeType == QilNodeType.Unknown);

            EnterScope(tmpl);

            CheckSingletonFocus();
            funcFocus.StartFocus(tmpl.Function.Arguments, !IsDebug ? tmpl.Flags : XslFlags.FullFocus);
            foreach (QilParameter arg in tmpl.Function.Arguments) {
                if (arg.Name.NamespaceUri != XmlReservedNs.NsXslDebug) {
                    Debug.Assert(tmpl is Template, "Only templates can have explicit arguments");
                    if (IsDebug) {
                        Debug.Assert(arg.DefaultValue == null, "Argument must not be compiled yet");
                        VarPar xslParam = (VarPar)arg.Annotation;
                        QilList nsListParam = EnterScope(xslParam);
                        arg.DefaultValue = CompileVarParValue(xslParam);
                        ExitScope();
                        arg.DefaultValue = SetDebugNs(arg.DefaultValue, nsListParam);
                    } else {
                        // in !IsDebug we compile argument default value in PrecompileProtoTemplatesHeaders()
                    }
                    scope.AddVariable(arg.Name, arg);
                }
            }
            tmpl.Function.Definition = CompileInstructions(tmpl.Content);
            // tmpl.Function.Definition = AddCurrentPositionLast(tmpl.Function.Definition); We don't mask Cur,Pos,Last parameters with Cur,Pos,Last wariables any more
            // tmpl.Function.Definition = SetDebugNs(tmpl.Function.Definition, nsList); We add it as parameter now.
            funcFocus.StopFocus();

            ExitScope();
        }

        private QilList InstructionList() {
            return f.BaseFactory.Sequence();
        }

        private QilNode CompileInstructions(IList<XslNode> instructions) {
            return CompileInstructions(instructions, 0, InstructionList());
        }

        private QilNode CompileInstructions(IList<XslNode> instructions, int from) {
            return CompileInstructions(instructions, from, InstructionList());
        }

        private QilNode CompileInstructions(IList<XslNode> instructions, QilList content) {
            return CompileInstructions(instructions, 0, content);
        }

        private QilNode CompileInstructions(IList<XslNode> instructions, int from, QilList content) {
            Debug.Assert(instructions != null);
            for (int i = from; i < instructions.Count; i++) {
                XslNode     node     = instructions[i];
                XslNodeType nodeType = node.NodeType;
                if (nodeType == XslNodeType.Param) {
                    continue; // already compiled by CompileProtoTemplate()
                }
                QilList     nsList   = EnterScope(node);
                QilNode     result;

                switch (nodeType) {
                case XslNodeType.ApplyImports:      result = CompileApplyImports    (node); break;
                case XslNodeType.ApplyTemplates:    result = CompileApplyTemplates  ((XslNodeEx)node); break;
                case XslNodeType.Attribute:         result = CompileAttribute       ((NodeCtor)node); break;
                case XslNodeType.CallTemplate:      result = CompileCallTemplate    ((XslNodeEx)node); break;
                case XslNodeType.Choose:            result = CompileChoose          (node); break;
                case XslNodeType.Comment:           result = CompileComment         (node); break;
                case XslNodeType.Copy:              result = CompileCopy            (node); break;
                case XslNodeType.CopyOf:            result = CompileCopyOf          (node); break;
                case XslNodeType.Element:           result = CompileElement         ((NodeCtor)node); break;
                case XslNodeType.Error:             result = CompileError           (node); break;
                case XslNodeType.ForEach:           result = CompileForEach         ((XslNodeEx)node); break;
                case XslNodeType.If:                result = CompileIf              (node); break;
                case XslNodeType.List:              result = CompileList            (node); break;
                case XslNodeType.LiteralAttribute:  result = CompileLiteralAttribute(node); break;
                case XslNodeType.LiteralElement:    result = CompileLiteralElement  (node); break;
                case XslNodeType.Message:           result = CompileMessage         (node); break;
                case XslNodeType.Nop:               result = CompileNop             (node); break;
                case XslNodeType.Number:            result = CompileNumber          ((Number)node); break;
//              case XslNodeType.Otherwise:         wrapped by Choose
//              case XslNodeType.Param:             already compiled by CompileProtoTemplate()
                case XslNodeType.PI:                result = CompilePI              (node); break;
//              case XslNodeType.Sort:              wrapped by ForEach or ApplyTemplates, see CompileSorts()
//              case XslNodeType.Template:          global level element
                case XslNodeType.Text:              result = CompileText            ((Text)node); break;
                case XslNodeType.UseAttributeSet:   result = CompileUseAttributeSet (node); break;
                case XslNodeType.ValueOf:           result = CompileValueOf         (node); break;
                case XslNodeType.ValueOfDoe:        result = CompileValueOfDoe      (node); break;
                case XslNodeType.Variable:          result = CompileVariable        (node); break;
//              case XslNodeType.WithParam:         wrapped by CallTemplate or ApplyTemplates, see CompileWithParam()
                default:                            Debug.Fail("Unexpected type of AST node: " + nodeType.ToString()); result = null; break;
                }

                ExitScope();
                Debug.Assert(result != null, "Result of compilation should not be null");
                if (result.NodeType == QilNodeType.Sequence && result.Count == 0) {
                    continue;
                }

                // Do not create sequence points for literal attributes and use-attribute-sets
                if (nodeType != XslNodeType.LiteralAttribute && nodeType != XslNodeType.UseAttributeSet) {
                    SetLineInfoCheck(result, node.SourceLine);
                }

                result = SetDebugNs(result, nsList);
                if (nodeType == XslNodeType.Variable) {
                    QilIterator var = f.Let(result);
                    var.DebugName = node.Name.ToString();
                    scope.AddVariable(node.Name, var);
                    // Process all remaining instructions in the recursive call
                    result = f.Loop(var, CompileInstructions(instructions, i + 1));
                    i = instructions.Count;
                }

                content.Add(result);
            }
            if (!IsDebug && content.Count == 1) {
                return content[0];
            }
            return content;
        }

        private QilNode CompileList(XslNode node) {
            return CompileInstructions(node.Content);
        }

        private QilNode CompileNop(XslNode node) {
            return f.Nop(f.Sequence());
        }

        private void AddNsDecl(QilList content, string prefix, string nsUri) {
            if (this.outputScope.LookupNamespace(prefix) == nsUri) {
                return; // This prefix is already bound to required namespace. Nothing to do.
            }
            this.outputScope.AddNamespace(prefix, nsUri);
            content.Add(f.NamespaceDecl(f.String(prefix), f.String(nsUri)));
        }

        private QilNode CompileLiteralElement(XslNode node) {
            // IlGen requires that namespace declarations do not conflict with the namespace used by the element
            // constructor, see XmlILNamespaceAnalyzer.CheckNamespaceInScope() and SQLBUDT 389481, 389482. First
            // we try to replace all prefixes bound to aliases by result-prefixes of the corresponding
            // xsl:namespace-alias instructions. If there is at least one conflict, we leave all prefixes
            // untouched, changing only namespace URIs.
            bool changePrefixes = true;

        Start:
            prefixesInUse.Clear();

            QilName qname   = node.Name;
            string  prefix  = qname.Prefix;
            string  nsUri   = qname.NamespaceUri;

            compiler.ApplyNsAliases(ref prefix, ref nsUri);
            if (changePrefixes) {
                prefixesInUse.Add(prefix, nsUri);
            } else {
                prefix = qname.Prefix;
            }

            outputScope.PushScope();

            // Declare all namespaces that should be declared
            // <spec>http://www.w3.org/TR/xslt.html#literal-result-element</spec>
            QilList nsList = InstructionList();
            foreach (ScopeRecord rec in this.scope) {
                string recPrefix = rec.ncName;
                string recNsUri  = rec.nsUri;
                if (recNsUri != XmlReservedNs.NsXslt && !scope.IsExNamespace(recNsUri)) {
                    compiler.ApplyNsAliases(ref recPrefix, ref recNsUri);
                    if (changePrefixes) {
                        if (prefixesInUse.Contains(recPrefix)) {
                            if ((string)prefixesInUse[recPrefix] != recNsUri) {
                                // Found a prefix conflict. Start again from the beginning leaving all prefixes untouched.
                                outputScope.PopScope();
                                changePrefixes = false;
                                goto Start;
                            }
                        } else {
                            prefixesInUse.Add(recPrefix, recNsUri);
                        }
                    } else {
                        recPrefix = rec.ncName;
                    }
                    AddNsDecl(nsList, recPrefix, recNsUri);
                }
            }

            QilNode content = CompileInstructions(node.Content, nsList);
            outputScope.PopScope();

            qname.Prefix = prefix;
            qname.NamespaceUri = nsUri;
            return f.ElementCtor(qname, content);
        }

        private QilNode CompileElement(NodeCtor node) {
            QilNode qilNs   = CompileStringAvt(node.NsAvt);
            QilNode qilName = CompileStringAvt(node.NameAvt);
            QilNode qname;

            if (qilName.NodeType == QilNodeType.LiteralString && (qilNs == null || qilNs.NodeType == QilNodeType.LiteralString)) {
                string name = (string)(QilLiteral)qilName;
                string prefix, local, nsUri;

                bool isValid = compiler.ParseQName(name, out prefix, out local, (IErrorHelper)this);

                if (qilNs == null) {
                    nsUri = isValid ? ResolvePrefix(/*ignoreDefaultNs:*/false, prefix) : compiler.CreatePhantomNamespace();
                } else {
                    nsUri = (string)(QilLiteral)qilNs;
                }
                qname = f.QName(local, nsUri, prefix);
            } else {           // Process AVT
                if (qilNs != null) {
                    qname = f.StrParseQName(qilName, qilNs);
                } else {
                    qname = ResolveQNameDynamic(/*ignoreDefaultNs:*/false, qilName);
                }
            }

            outputScope.PushScope();
            // ToDo if we don't have AVT we shouldn't do this:
            this.outputScope.InvalidateAllPrefixes();
            QilNode content = CompileInstructions(node.Content);
            outputScope.PopScope();

            return f.ElementCtor(qname, content);
        }

        private QilNode CompileLiteralAttribute(XslNode node) {
            QilName qname   = node.Name;
            string  prefix  = qname.Prefix;
            string  nsUri   = qname.NamespaceUri;
            // The default namespace do not apply directly to attributes
            if (prefix.Length != 0) {
                compiler.ApplyNsAliases(ref prefix, ref nsUri);
            }
            qname.Prefix = prefix;
            qname.NamespaceUri = nsUri;
            return f.AttributeCtor(qname, CompileTextAvt(node.Select));
        }

        private QilNode CompileAttribute(NodeCtor node) {
            QilNode qilNs   = CompileStringAvt(node.NsAvt);
            QilNode qilName = CompileStringAvt(node.NameAvt);
            QilNode qname;
            bool    explicitNamespace = false;

            if (qilName.NodeType == QilNodeType.LiteralString && (qilNs == null || qilNs.NodeType == QilNodeType.LiteralString)) {
                string name  = (string)(QilLiteral)qilName;
                string prefix, local, nsUri;

                bool isValid = compiler.ParseQName(name, out prefix, out local, (IErrorHelper)this);

                if (qilNs == null) {
                    nsUri = isValid ? ResolvePrefix(/*ignoreDefaultNs:*/true, prefix) : compiler.CreatePhantomNamespace();
                } else {
                    nsUri = (string)(QilLiteral)qilNs;
                    // if both name and ns are non AVT and this ns is already bind to the same prefix we can avoid reseting ns management
                    explicitNamespace = true;
                }
                // Check the case <xsl:attribute name="foo:xmlns" namespace=""/>
                if (name == "xmlns" || local == "xmlns" && nsUri.Length == 0) {
                    ReportError(/*[XT_031]*/Res.Xslt_XmlnsAttr, "name", name);
                }
                qname = f.QName(local, nsUri, prefix);
            } else {
                // Process AVT
                if (qilNs != null) {
                    qname = f.StrParseQName(qilName, qilNs);
                } else {
                    qname = ResolveQNameDynamic(/*ignoreDefaultNs:*/true, qilName);
                }
            }
            if (explicitNamespace) {
                // Optimization: attribute cannot change the default namespace
                this.outputScope.InvalidateNonDefaultPrefixes();
            }
            return f.AttributeCtor(qname, CompileInstructions(node.Content));
        }

        private readonly StringBuilder unescapedText = new StringBuilder();

        private QilNode ExtractText(string source, ref int pos) {
            Debug.Assert(pos < source.Length);
            int i, start = pos;

            unescapedText.Length = 0;
            for (i = pos; i < source.Length; i++) {
                char ch = source[i];

                if (ch == '{' || ch == '}') {
                    if (i + 1 < source.Length && source[i + 1] == ch) {     // "{{" or "}}"
                        // Double curly brace outside an expression is replaced by a single one
                        i++;
                        unescapedText.Append(source, start, i - start);
                        start = i + 1;
                    } else if (ch == '{') {                                 // single '{'
                        // Expression encountered, returning
                        break;
                    } else {                                                // single '}'
                        // Single '}' outside an expression is an error
                        pos = source.Length;
                        if (xslVersion != XslVersion.ForwardsCompatible) {
                            ReportError(/*[XT0370]*/Res.Xslt_SingleRightBraceInAvt, source);
                            return null;
                        }
                        return f.Error(lastScope.SourceLine, Res.Xslt_SingleRightBraceInAvt, source);
                    }
                }
            }

            Debug.Assert(i == source.Length || source[i] == '{');
            pos = i;
            if (unescapedText.Length == 0) {
                return i > start ? f.String(source.Substring(start, i - start)) : null;
            } else {
                unescapedText.Append(source, start, i - start);
                return f.String(unescapedText.ToString());
            }
        }

        private QilNode CompileAvt(string source) {
            QilList result = f.BaseFactory.Sequence();
            int pos = 0;
            while (pos < source.Length) {
                QilNode fixedPart = ExtractText(source, ref pos);
                if (fixedPart != null) {
                    result.Add(fixedPart);
                }
                if (pos < source.Length) { // '{' encountered, parse an expression
                    pos++;
                    QilNode exp = CompileXPathExpressionWithinAvt(source, ref pos);
                    result.Add(f.ConvertToString(exp));
                }
            }
            if (result.Count == 1) {
                return result[0];
            }
            return result;
        }

        static readonly char[] curlyBraces = {'{', '}'};

        private QilNode CompileStringAvt(string avt) {
            if (avt == null) {
                return null;
            }
            if (avt.IndexOfAny(curlyBraces) == -1) {
                return f.String(avt);
            }
            return f.StrConcat(CompileAvt(avt));
        }

        private QilNode CompileTextAvt(string avt) {
            Debug.Assert(avt != null);
            if (avt.IndexOfAny(curlyBraces) == -1) {
                return f.TextCtor(f.String(avt));
            }
            QilNode avtParts = CompileAvt(avt);
            if (avtParts.NodeType == QilNodeType.Sequence) {
                QilList result = InstructionList();
                foreach (QilNode node in avtParts) {
                    result.Add(f.TextCtor(node));
                }
                return result;
            } else {
                return f.TextCtor(avtParts);
            }
        }

        private QilNode CompileText(Text node) {
            if (node.Hints == SerializationHints.None)
                return f.TextCtor(f.String(node.Select));

            return f.RawTextCtor(f.String(node.Select));
        }

        private QilNode CompilePI(XslNode node) {
            QilNode qilName = CompileStringAvt(node.Select);
            if (qilName.NodeType == QilNodeType.LiteralString) {
                string name = (string)(QilLiteral)qilName;
                compiler.ValidatePiName(name, (IErrorHelper)this);
            }
            return f.PICtor(qilName, CompileInstructions(node.Content));
        }

        private QilNode CompileComment(XslNode node) {
            return f.CommentCtor(CompileInstructions(node.Content));
        }

        private QilNode CompileError(XslNode node) {
            return f.Error(f.String(node.Select));
        }

        private QilNode WrapLoopBody(ISourceLineInfo before, QilNode expr, ISourceLineInfo after) {
            Debug.Assert(curLoop.IsFocusSet);
            if (IsDebug) {
                return f.Sequence(
                    SetLineInfo(InvokeOnCurrentNodeChanged(), before),
                    expr,
                    SetLineInfo(f.Nop(f.Sequence()), after)
                );
            }
            return expr;
        }

        private QilNode CompileForEach(XslNodeEx node) {
            QilNode         result;
            IList<XslNode>  content = node.Content;

            // Push new loop frame on the stack
            LoopFocus curLoopSaved = curLoop;
            QilIterator it = f.For(CompileNodeSetExpression(node.Select));
            curLoop.SetFocus(it);

            // Compile sort keys and body
            int varScope = varHelper.StartVariables();
            curLoop.Sort(CompileSorts(content, ref curLoopSaved));
            result = CompileInstructions(content);
            result = WrapLoopBody(node.ElemNameLi, result, node.EndTagLi);
            result = AddCurrentPositionLast(result);
            result = curLoop.ConstructLoop(result);
            result = varHelper.FinishVariables(result, varScope);

            // Pop loop frame
            curLoop = curLoopSaved;
            return result;
        }

        private QilNode CompileApplyTemplates(XslNodeEx node) {
            QilNode         result;
            IList<XslNode>  content = node.Content;

            // Calculate select expression
            int varScope = varHelper.StartVariables();

            QilIterator select = f.Let(CompileNodeSetExpression(node.Select));
            varHelper.AddVariable(select);

            // Compile with-param's, they must be calculated outside the loop and
            // if they are neither constant nor reference we need to cache them in Let's
            for (int i = 0; i < content.Count; i++) {
                VarPar withParam = content[i] as VarPar;
                if (withParam != null) {
                    Debug.Assert(withParam.NodeType == XslNodeType.WithParam);
                    CompileWithParam(withParam);
                    QilNode val = withParam.Value;
                    if (IsDebug || !(val is QilIterator || val is QilLiteral)) {
                        QilIterator let = f.Let(val);
                        let.DebugName = f.QName("with-param " + withParam.Name.QualifiedName, XmlReservedNs.NsXslDebug).ToString();
                        varHelper.AddVariable(let);
                        withParam.Value = let;
                    }
                }
            }

            // Push new loop frame on the stack
            LoopFocus curLoopSaved = curLoop;
            QilIterator it = f.For(select);
            curLoop.SetFocus(it);

            // Compile sort keys and body
            curLoop.Sort(CompileSorts(content, ref curLoopSaved));

            result = GenerateApply(compiler.Root, node);

            result = WrapLoopBody(node.ElemNameLi, result, node.EndTagLi);
            result = AddCurrentPositionLast(result);
            result = curLoop.ConstructLoop(result);

            // Pop loop frame
            curLoop = curLoopSaved;

            result = varHelper.FinishVariables(result, varScope);
            return result;
        }

        private QilNode CompileApplyImports(XslNode node) {
            Debug.Assert(node.NodeType == XslNodeType.ApplyImports);
            Debug.Assert(!curLoop.IsFocusSet, "xsl:apply-imports cannot be inside of xsl:for-each");

            return GenerateApply((StylesheetLevel)node.Arg, node);
        }

        private QilNode CompileCallTemplate(XslNodeEx node) {
            VerifyXPathQName(node.Name);
            int varScope = varHelper.StartVariables();

            IList<XslNode> content = node.Content;
            foreach (VarPar withParam in content) {
                CompileWithParam(withParam);
                // In debug mode precalculate all with-param's
                if (IsDebug) {
                    QilNode val = withParam.Value;
                    QilIterator let = f.Let(val);
                    let.DebugName = f.QName("with-param " + withParam.Name.QualifiedName, XmlReservedNs.NsXslDebug).ToString();
                    varHelper.AddVariable(let);
                    withParam.Value = let;
                }
            }

            QilNode result; {
                Template tmpl;
                if (compiler.NamedTemplates.TryGetValue(node.Name, out tmpl)) {
                    Debug.Assert(tmpl.Function != null, "All templates should be already compiled");
                    result = invkGen.GenerateInvoke(tmpl.Function, AddRemoveImplicitArgs(node.Content, tmpl.Flags));
                } else {
                    if (! compiler.IsPhantomName(node.Name)) {
                        compiler.ReportError(/*[XT0710]*/node.SourceLine, Res.Xslt_InvalidCallTemplate, node.Name.QualifiedName);
                    }
                    result = f.Sequence();
                }
            }

            // Do not create an additional sequence point if there are no parameters
            if (content.Count > 0) {
                result = SetLineInfo(result, node.ElemNameLi);
            }
            result = varHelper.FinishVariables(result, varScope);
            if (IsDebug) {
                return f.Nop(result);
            }
            return result;
        }

        private QilNode CompileUseAttributeSet(XslNode node) {
            VerifyXPathQName(node.Name);
            // 
            outputScope.InvalidateAllPrefixes();

            AttributeSet attSet;
            if (compiler.AttributeSets.TryGetValue(node.Name, out attSet)) {
                Debug.Assert(attSet.Function != null, "All templates should be already compiled");
                return invkGen.GenerateInvoke(attSet.Function, AddRemoveImplicitArgs(node.Content, attSet.Flags));
            } else {
                if (! compiler.IsPhantomName(node.Name)) {
                    compiler.ReportError(/*[XT0710]*/node.SourceLine, Res.Xslt_NoAttributeSet, node.Name.QualifiedName);
                }
                return f.Sequence();
            }
        }

        private const XmlNodeKindFlags InvalidatingNodes = (XmlNodeKindFlags.Attribute | XmlNodeKindFlags.Namespace);

        private QilNode CompileCopy(XslNode copy) {
            QilNode node = GetCurrentNode();
            f.CheckNodeNotRtf(node);
            if ((node.XmlType.NodeKinds & InvalidatingNodes) != XmlNodeKindFlags.None) {
                outputScope.InvalidateAllPrefixes();
            }
            if (node.XmlType.NodeKinds == XmlNodeKindFlags.Element) {
                // Context node is always an element
                // The namespace nodes of the current node are automatically copied
                QilList content = InstructionList();
                content.Add(f.XPathNamespace(node));
                outputScope.PushScope();
                outputScope.InvalidateAllPrefixes();
                QilNode result = CompileInstructions(copy.Content, content);
                outputScope.PopScope();
                return f.ElementCtor(f.NameOf(node), result);
            } else if (node.XmlType.NodeKinds == XmlNodeKindFlags.Document) {
                // Context node is always a document
                // xsl:copy will not create a document node, but will just use the content template
                return CompileInstructions(copy.Content);
            } else if ((node.XmlType.NodeKinds & (XmlNodeKindFlags.Element | XmlNodeKindFlags.Document)) == XmlNodeKindFlags.None) {
                // Context node is neither an element, nor a document
                // The content of xsl:copy is not instantiated
                return node;
            } else {
                // Static classifying of the context node is not possible
                return f.XsltCopy(node, CompileInstructions(copy.Content));
            }
        }

        private QilNode CompileCopyOf(XslNode node) {
            QilNode selectExpr = CompileXPathExpression(node.Select);
            if (selectExpr.XmlType.IsNode) {
                if ((selectExpr.XmlType.NodeKinds & InvalidatingNodes) != XmlNodeKindFlags.None) {
                    outputScope.InvalidateAllPrefixes();
                }

                if (selectExpr.XmlType.IsNotRtf && (selectExpr.XmlType.NodeKinds & XmlNodeKindFlags.Document) == XmlNodeKindFlags.None) {
                    // Expression returns non-document nodes only
                    return selectExpr;
                }

                // May be an Rtf or may return Document nodes, so use XsltCopyOf operator
                if (selectExpr.XmlType.IsSingleton) {
                    return f.XsltCopyOf(selectExpr);
                } else {
                    QilIterator it;
                    return f.Loop(it = f.For(selectExpr), f.XsltCopyOf(it));
                }
            }
            else if (selectExpr.XmlType.IsAtomicValue) {
                // Expression returns non-nodes only
                // When the result is neither a node-set nor a result tree fragment, the result is converted
                // to a string and then inserted into the result tree, as with xsl:value-of.
                return f.TextCtor(f.ConvertToString(selectExpr));
            }
            else {
                // Static classifying is not possible
                QilIterator it;
                outputScope.InvalidateAllPrefixes();
                return f.Loop(
                    it = f.For(selectExpr),
                    f.Conditional(f.IsType(it, T.Node),
                        f.XsltCopyOf(f.TypeAssert(it, T.Node)),
                        f.TextCtor(f.XsltConvert(it, T.StringX))
                    )
                );
            }
        }

        private QilNode CompileValueOf(XslNode valueOf) {
            return f.TextCtor(f.ConvertToString(CompileXPathExpression(/*select:*/valueOf.Select)));
        }

        private QilNode CompileValueOfDoe(XslNode valueOf) {
            return f.RawTextCtor(f.ConvertToString(CompileXPathExpression(/*select:*/valueOf.Select)));
        }

        private QilNode CompileWhen(XslNode whenNode, QilNode otherwise) {
            return f.Conditional(
                f.ConvertToBoolean(CompileXPathExpression(/*test:*/whenNode.Select)),
                CompileInstructions(whenNode.Content),
                otherwise
            );
        }

        private QilNode CompileIf(XslNode ifNode) {
            return CompileWhen(ifNode, InstructionList());
        }

        private QilNode CompileChoose(XslNode node) {
            IList<XslNode> cases = node.Content;
            QilNode result = null;

            // It's easier to compile xsl:choose from bottom to top
            for (int i = cases.Count - 1; 0 <= i; i--) {
                XslNode when = cases[i];
                Debug.Assert(when.NodeType == XslNodeType.If || when.NodeType == XslNodeType.Otherwise);
                QilList nsList = EnterScope(when);
                if (when.NodeType == XslNodeType.Otherwise) {
                    Debug.Assert(result == null, "xsl:otherwise must be the last child of xsl:choose");
                    result = CompileInstructions(when.Content);
                } else {
                    result = CompileWhen(when, /*otherwise:*/result ?? InstructionList());
                }
                ExitScope();
                SetLineInfoCheck(result, when.SourceLine);
                result = SetDebugNs(result, nsList);
            }
            if (result == null) {
                return f.Sequence();
            }
            return IsDebug ? f.Sequence(result) : result;
        }

        private QilNode CompileMessage(XslNode node) {
            string  baseUri = lastScope.SourceLine.Uri;
            QilNode content = f.RtfCtor(CompileInstructions(node.Content), f.String(baseUri));

            //content = f.ConvertToString(content);
            content = f.InvokeOuterXml(content);

            // If terminate="no", then create QilNodeType.Warning
            if (!(bool)node.Arg) {
                return f.Warning(content);
            }

            // Otherwise create both QilNodeType.Warning and QilNodeType.Error
            QilIterator i;
            return f.Loop(i = f.Let(content), f.Sequence(f.Warning(i), f.Error(i)));
        }

        private QilNode CompileVariable(XslNode node) {
            Debug.Assert(node.NodeType == XslNodeType.Variable);
            if (scope.IsLocalVariable(node.Name.LocalName, node.Name.NamespaceUri)) {
                ReportError(/*[XT_030]*/Res.Xslt_DupLocalVariable, node.Name.QualifiedName);
            }
            return CompileVarParValue(node);
        }

        private QilNode CompileVarParValue(XslNode node) {
            Debug.Assert(node.NodeType == XslNodeType.Variable || node.NodeType == XslNodeType.Param || node.NodeType == XslNodeType.WithParam);
            VerifyXPathQName(node.Name);

            string          baseUri = lastScope.SourceLine.Uri;
            IList<XslNode>  content = node.Content;
            string          select  = node.Select;
            QilNode         varValue;

            if (select != null) {
                // In case of incorrect stylesheet, variable or parameter may have both a 'select' attribute and non-empty content
                QilList list = InstructionList();
                list.Add(CompileXPathExpression(select));
                varValue = CompileInstructions(content, list);
            } else if (content.Count != 0) {
                this.outputScope.PushScope();
                // Rtf will be instantiated in an unknown namespace context, so we should not assume anything here
                this.outputScope.InvalidateAllPrefixes();
                varValue = f.RtfCtor(CompileInstructions(content), f.String(baseUri));
                this.outputScope.PopScope();
            } else {
                varValue = f.String(string.Empty);
            }
            if (IsDebug) {
                // In debug mode every variable/param must be of type 'any'
                varValue = f.TypeAssert(varValue, T.ItemS);
            }
            Debug.Assert(varValue.SourceLine == null);
            return varValue;
        }

        private void CompileWithParam(VarPar withParam) {
            Debug.Assert(withParam.NodeType == XslNodeType.WithParam);
            QilList nsList = EnterScope(withParam);
            QilNode paramValue = CompileVarParValue(withParam);
            ExitScope();
            SetLineInfo(paramValue, withParam.SourceLine);
            paramValue = SetDebugNs(paramValue, nsList);
            withParam.Value = paramValue;
        }

        // 

        private QilNode CompileSorts(IList<XslNode> content, ref LoopFocus parentLoop) {
            QilList keyList = f.BaseFactory.SortKeyList();

            int i = 0;

            while (i < content.Count) {
                Sort sort = content[i] as Sort;
                if (sort != null) {
                    CompileSort(sort, keyList, ref parentLoop);
                    content.RemoveAt(i);
                } else {
                    i++;
                }
            }

            if (keyList.Count == 0)
                return null;

            return keyList;
        }

        private QilNode CompileLangAttribute(string attValue, bool fwdCompat) {
            QilNode result = CompileStringAvt(attValue);

            if (result == null) {
                // Do nothing
            } else if (result.NodeType == QilNodeType.LiteralString) {
                string lang = (string)(QilLiteral)result;
                int lcid = XsltLibrary.LangToLcidInternal(lang, fwdCompat, (IErrorHelper)this);
                if (lcid == XsltLibrary.InvariantCultureLcid) {
                    result = null;
                }
            } else {
                // NOTE: We should have the same checks for both compile time and execution time
                QilIterator i;
                result = f.Loop(i = f.Let(result),
                    f.Conditional(f.Eq(f.InvokeLangToLcid(i, fwdCompat), f.Int32(XsltLibrary.InvariantCultureLcid)),
                        f.String(string.Empty),
                        i
                    )
                );
            }
            return result;
        }

        private QilNode CompileLangAttributeToLcid(string attValue, bool fwdCompat) {
            return CompileLangToLcid(CompileStringAvt(attValue), fwdCompat);
         }

        private QilNode CompileLangToLcid(QilNode lang, bool fwdCompat) {
            if (lang == null) {
                return f.Double(XsltLibrary.InvariantCultureLcid);
            } else if (lang.NodeType == QilNodeType.LiteralString) {
                return f.Double(XsltLibrary.LangToLcidInternal((string)(QilLiteral)lang, fwdCompat, (IErrorHelper)this));
            } else {
                return f.XsltConvert(f.InvokeLangToLcid(lang, fwdCompat), T.DoubleX);
            }
        }

        private void CompileDataTypeAttribute(string attValue, bool fwdCompat, ref QilNode select, out QilNode select2) {
            const string DtText   = "text";
            const string DtNumber = "number";
            QilNode result = CompileStringAvt(attValue);
            if (result != null) {
                if (result.NodeType == QilNodeType.LiteralString) {
                    string dataType = (string)(QilLiteral)result;
                    if (dataType == DtNumber) {
                        select  = f.ConvertToNumber(select);
                        select2 = null;
                        return;
                    } else if (dataType == DtText) {
                        // fall through to default case
                    } else {
                        if (!fwdCompat) {
                            // check for qname-but-not-ncname
                            string prefix, local, nsUri;
                            bool isValid = compiler.ParseQName(dataType, out prefix, out local, (IErrorHelper)this);
                            nsUri = isValid ? ResolvePrefix(/*ignoreDefaultNs:*/true, prefix) : compiler.CreatePhantomNamespace();

                            if (nsUri.Length == 0) {
                                // this is a ncname; we might report Res.Xslt_InvalidAttrValue,
                                // but the following error message is more user friendly
                            }
                            ReportError(/*[XT_034]*/Res.Xslt_BistateAttribute, "data-type", DtText, DtNumber);
                        }
                        // fall through to default case
                    }
                } else {
                    // Precalculate its value outside of for-each loop
                    QilIterator dt, qname;

                    result = f.Loop(dt = f.Let(result),
                        f.Conditional(f.Eq(dt, f.String(DtNumber)), f.False(),
                        f.Conditional(f.Eq(dt, f.String(DtText)),   f.True(),
                        fwdCompat ? f.True() :
                        f.Loop(qname = f.Let(ResolveQNameDynamic(/*ignoreDefaultNs:*/true, dt)),
                            f.Error(lastScope.SourceLine,
                                Res.Xslt_BistateAttribute, "data-type", DtText, DtNumber
                            )
                        )
                    )));

                    QilIterator text = f.Let(result);
                    varHelper.AddVariable(text);

                    // Make two sort keys since heterogenous sort keys are not allowed
                    select2 = select.DeepClone(f.BaseFactory);
                    select  = f.Conditional(text, f.ConvertToString(select), f.String(string.Empty)    );
                    select2 = f.Conditional(text, f.Double(0),               f.ConvertToNumber(select2));
                    return;
                }
            }

            // Default case
            select  = f.ConvertToString(select);
            select2 = null;
        }

        /// <summary>
        /// Compiles AVT with two possible values
        /// </summary>
        /// <param name="attName"  >NodeCtor name (used for constructing an error message)</param>
        /// <param name="attValue" >NodeCtor value</param>
        /// <param name="value0"   >First possible value of attribute</param>
        /// <param name="value1"   >Second possible value of attribute</param>
        /// <param name="fwdCompat">If true, unrecognized value does not report an error</param>
        /// <returns>
        /// If AVT is null (i.e. the attribute is omitted), null is returned. Otherwise, QilExpression
        /// returning "1" if AVT evaluates to value1, or "0" if AVT evaluates to value0 or any other value.
        /// If AVT evaluates to neither value0 nor value1 and fwdCompat == false, an error is reported.
        /// </returns>
        private QilNode CompileOrderAttribute(string attName, string attValue, string value0, string value1, bool fwdCompat) {
            QilNode result = CompileStringAvt(attValue);
            if (result != null) {
                if (result.NodeType == QilNodeType.LiteralString) {
                    string value = (string)(QilLiteral)result;
                    if (value == value1) {
                        result = f.String("1");
                    } else {
                        if (value != value0 && !fwdCompat) {
                            ReportError(/*[XT_034]*/Res.Xslt_BistateAttribute, attName, value0, value1);
                        }
                        result = f.String("0");
                    }
                } else {
                    QilIterator i;
                    result = f.Loop(i = f.Let(result),
                        f.Conditional(f.Eq(i, f.String(value1)), f.String("1"),
                        fwdCompat ? f.String("0") :
                        f.Conditional(f.Eq(i, f.String(value0)), f.String("0"),
                        f.Error(lastScope.SourceLine,
                            Res.Xslt_BistateAttribute, attName, value0, value1
                        )
                    )));
                }
                Debug.Assert(result.XmlType == T.StringX);
            }
            return result;
        }

        private void CompileSort(Sort sort, QilList keyList, ref LoopFocus parentLoop) {
            Debug.Assert(sort.NodeType == XslNodeType.Sort);
            QilNode select, select2, lang, order, caseOrder;
            bool    fwdCompat;

            EnterScope(sort);
            fwdCompat = sort.ForwardsCompatible;

            select = CompileXPathExpression(sort.Select);

            if (sort.Lang != null || sort.DataType != null || sort.Order != null || sort.CaseOrder != null) {
                // Calculate these attributes in the context of the parent loop
                LoopFocus curLoopSaved = curLoop;
                curLoop = parentLoop;

                lang = CompileLangAttribute(sort.Lang, fwdCompat);

                CompileDataTypeAttribute(sort.DataType, fwdCompat, ref select, out select2);

                order = CompileOrderAttribute(
                    /*attName:  */  "order",
                    /*attValue: */  sort.Order,
                    /*value0:   */  "ascending",
                    /*value1:   */  "descending",
                    /*fwdCompat:*/  fwdCompat
                );

                caseOrder = CompileOrderAttribute(
                    /*attName:  */  "case-order",
                    /*attValue: */  sort.CaseOrder,
                    /*value0:   */  "lower-first",
                    /*value1:   */  "upper-first",
                    /*fwdCompat:*/  fwdCompat
                );

                // Restore loop context
                curLoop = curLoopSaved;
            } else {
                select  = f.ConvertToString(select);
                select2 = lang = order = caseOrder = null;
            }

            strConcat.Reset();
            strConcat.Append(XmlReservedNs.NsCollationBase);
            strConcat.Append('/');
            strConcat.Append(lang);

            char separator = '?';
            if (order != null) {
                strConcat.Append(separator);
                strConcat.Append("descendingOrder=");
                strConcat.Append(order);
                separator = '&';
            }
            if (caseOrder != null) {
                strConcat.Append(separator);
                strConcat.Append("upperFirst=");
                strConcat.Append(caseOrder);
                separator = '&';
            }

            QilNode collation = strConcat.ToQil();

            QilSortKey result = f.SortKey(select, collation);
            // Line information is not copied
            keyList.Add(result);

            if (select2 != null) {
                result = f.SortKey(select2, collation.DeepClone(f.BaseFactory));
                // Line information is not copied
                keyList.Add(result);
            }

            ExitScope();
        }

        private QilNode MatchPattern(QilNode pattern, QilIterator testNode) {
            QilList list;
            if (pattern.NodeType == QilNodeType.Error) {
                // Invalid pattern
                return pattern;
            } else if (pattern.NodeType == QilNodeType.Sequence) {
                list = (QilList)pattern;
                Debug.Assert(0 < list.Count, "Pattern should have at least one filter");
            } else {
                list = f.BaseFactory.Sequence();
                list.Add(pattern);
            }

            QilNode result = f.False();
            for (int i = list.Count - 1; 0 <= i; i --) {
                QilLoop filter = (QilLoop) list[i];
                ptrnBuilder.AssertFilter(filter);
                result = f.Or(
                    refReplacer.Replace(filter.Body, filter.Variable, testNode),
                    result
                );
            }
            return result;
        }

        private QilNode MatchCountPattern(QilNode countPattern, QilIterator testNode) {
            /*
                If the 'count' attribute is not specified, then it defaults to the pattern that matches any node
                with the same node kind as the context node and, if the context node has an expanded-QName, with
                the same expanded-QName as the context node.
            */
            if (countPattern != null) {
                return MatchPattern(countPattern, testNode);
            } else {
                QilNode current = GetCurrentNode();
                QilNode result;
                XmlNodeKindFlags nodeKinds = current.XmlType.NodeKinds;

                // If node kind is not known, invoke a runtime function
                if ((nodeKinds & (nodeKinds - 1)) != 0) {
                    return f.InvokeIsSameNodeSort(testNode, current);
                }

                // Otherwise generate IsType check along with expanded QName check
                switch (nodeKinds) {
                case XmlNodeKindFlags.Document  :   return f.IsType(testNode, T.Document);
                case XmlNodeKindFlags.Element   :   result = f.IsType(testNode, T.Element);   break;
                case XmlNodeKindFlags.Attribute :   result = f.IsType(testNode, T.Attribute); break;
                case XmlNodeKindFlags.Text      :   return f.IsType(testNode, T.Text);
                case XmlNodeKindFlags.Comment   :   return f.IsType(testNode, T.Comment);
                case XmlNodeKindFlags.PI        :   return f.And(f.IsType(testNode, T.PI)       , f.Eq(f.LocalNameOf(testNode), f.LocalNameOf(current)));
                case XmlNodeKindFlags.Namespace :   return f.And(f.IsType(testNode, T.Namespace), f.Eq(f.LocalNameOf(testNode), f.LocalNameOf(current)));
                default :
                    Debug.Fail("Unexpected NodeKind: " + nodeKinds.ToString());
                    return f.False();
                }

                // Elements and attributes have both local name and namespace URI
                return f.And(result, f.And(
                    f.Eq(f.LocalNameOf(testNode)   , f.LocalNameOf(current)),
                    f.Eq(f.NamespaceUriOf(testNode), f.NamespaceUriOf(GetCurrentNode()))
                ));
            }
        }

        private QilNode PlaceMarker(QilNode countPattern, QilNode fromPattern, bool multiple) {
            /*
                Quotation from XSLT 2.0 spec:
                * Let $A be the node sequence selected by the expression
                    ancestor-or-self::node()[matches-count(.)]          (level = "multiple")
                    ancestor-or-self::node()[matches-count(.)][1]       (level = "single")
                * Let $F be the node sequence selected by the expression
                    ancestor-or-self::node()[matches-from(.)][1]
                * Let $AF be the value of
                    $A intersect ($F/descendant-or-self::node())
                * Return the result of the expression
                    for $af in $AF return 1+count($af/preceding-sibling::node()[matches-count(.)])

                NOTE: There are some distinctions between XSLT 1.0 and XSLT 2.0 specs. In our 1.0 implementation we:
                1) Assume that the 'matches-from()' function does not match root nodes by default.
                2) Instead of '$A intersect ($F/descendant-or-self::node())' (which, by the way,
                   would filter out attribute and namespace nodes from $A) we calculate
                     '$A'           if the 'from' attribute is omitted,
                     '$A[. >> $F]'  if the 'from' attribute is present.
            */

            QilNode     countPattern2, countMatches, fromMatches, A, F, AF;
            QilIterator i, j;

            countPattern2 = (countPattern != null) ? countPattern.DeepClone(f.BaseFactory) : null;
            countMatches = f.Filter(i = f.For(f.AncestorOrSelf(GetCurrentNode())), MatchCountPattern(countPattern, i));
            if (multiple) {
                A = f.DocOrderDistinct(countMatches);
            } else {
                A = f.Filter(i = f.For(countMatches), f.Eq(f.PositionOf(i), f.Int32(1)));
            }

            if (fromPattern == null) {
                AF = A;
            } else {
                fromMatches = f.Filter(i = f.For(f.AncestorOrSelf(GetCurrentNode())), MatchPattern(fromPattern, i));
                F = f.Filter(i = f.For(fromMatches), f.Eq(f.PositionOf(i), f.Int32(1)));
                AF = f.Loop(i = f.For(F), f.Filter(j = f.For(A), f.Before(i, j)));
            }

            return f.Loop(j = f.For(AF),
                f.Add(f.Int32(1), f.Length(f.Filter(i = f.For(f.PrecedingSibling(j)), MatchCountPattern(countPattern2, i))))
            );
        }

        private QilNode PlaceMarkerAny(QilNode countPattern, QilNode fromPattern) {
            /*
                Quotation from XSLT 2.0 spec:
                * If the context node is a document node, return the empty sequence, ()
                * Let $A be the node sequence selected by the expression
                    (preceding::node()|ancestor-or-self::node())[matches-count(.)]
                * Let $F be the node sequence selected by the expression
                    (preceding::node()|ancestor::node())[matches-from(.)][last()]
                * Let $AF be the node sequence $A[. is $F or . >> $F].
                * If $AF is empty, return the empty sequence, ()
                * Otherwise return the value of the expression count($AF)

                NOTE: There are some distinctions between XSLT 1.0 and XSLT 2.0 specs. In our 1.0 implementation we:
                1) Assume that the 'matches-from()' function does not match root nodes by default.
                2) Instead of '$A[. is $F or . >> $F]' we calculate
                     '$A'           if the 'from' attribute is omitted,
                     '$A[. >> $F]'  if the 'from' attribute is present.
            */

            QilNode     range, fromMatches, F, AF;
            QilIterator i, j, k;

            if (fromPattern == null) {
                // According to XSLT 2.0 spec, if the 'from' attribute is omitted, matches-from() returns true
                // only for the root node. It means $F is a sequence of length one containing the root node,
                // and $AF = $A. XSLT 1.0 spec rules lead to the same result $AF = $A, so two specs are compliant here.
                range = f.NodeRange(f.Root(GetCurrentNode()), GetCurrentNode());
                AF = f.Filter(i = f.For(range), MatchCountPattern(countPattern, i));
            } else {
                fromMatches = f.Filter(i = f.For(f.Preceding(GetCurrentNode())), MatchPattern(fromPattern, i));
                F = f.Filter(i = f.For(fromMatches), f.Eq(f.PositionOf(i), f.Int32(1)));
                AF = f.Loop(i = f.For(F),
                    f.Filter(j = f.For(f.Filter(k = f.For(f.NodeRange(i, GetCurrentNode())), MatchCountPattern(countPattern, k))),
                        f.Not(f.Is(i, j))
                    )
                );
            }

            return f.Loop(k = f.Let(f.Length(AF)),
                f.Conditional(f.Eq(k, f.Int32(0)), f.Sequence(),
                k
            ));
        }

        // Returns one of XsltLibrary.LetterValue enum values
        private QilNode CompileLetterValueAttribute(string attValue, bool fwdCompat) {
            const string Default     = "default";
            const string Alphabetic  = "alphabetic";
            const string Traditional = "traditional";

            string letterValue;
            QilNode result = CompileStringAvt(attValue);

            if (result != null) {
                if (result.NodeType == QilNodeType.LiteralString) {
                    letterValue = (string)(QilLiteral)result;
                    if (letterValue != Alphabetic && letterValue != Traditional) {
                        if (!fwdCompat) {
                            ReportError(/*[XT_034]*/Res.Xslt_BistateAttribute, "letter-value", Alphabetic, Traditional);
                        }
                        else {
                            // Use default value
                            return f.String(Default);
                        }
                    }
                    return result;
                } else {
                    QilIterator i = f.Let(result);
                    return f.Loop(i,
                        f.Conditional(
                            f.Or(f.Eq(i, f.String(Alphabetic)), f.Eq(i, f.String(Traditional))),
                            i,
                            fwdCompat ? f.String(Default) :
                            f.Error(lastScope.SourceLine, Res.Xslt_BistateAttribute, "letter-value", Alphabetic, Traditional)
                    ));
                }
            }
            return f.String(Default);
        }

        private QilNode CompileGroupingSeparatorAttribute(string attValue, bool fwdCompat) {
            QilNode result = CompileStringAvt(attValue);

            if (result == null) {
                // NOTE: string.Empty value denotes unspecified attribute
                result = f.String(string.Empty);
            } else if (result.NodeType == QilNodeType.LiteralString) {
                string value = (string)(QilLiteral)result;
                if (value.Length != 1) {
                    if (!fwdCompat) {
                        ReportError(/*[XT_035]*/Res.Xslt_CharAttribute, "grouping-separator");
                    }
                    // See the comment above
                    result = f.String(string.Empty);
                }
            } else {
                QilIterator i = f.Let(result);
                result = f.Loop(i,
                    f.Conditional(f.Eq(f.StrLength(i), f.Int32(1)), i,
                    fwdCompat ? f.String(string.Empty) :
                    f.Error(lastScope.SourceLine, Res.Xslt_CharAttribute, "grouping-separator")
                ));
            }
            return result;
        }

        private QilNode CompileGroupingSizeAttribute(string attValue, bool fwdCompat) {
            QilNode result = CompileStringAvt(attValue);

            if (result == null) {
                return f.Double(0);
            } else if (result.NodeType == QilNodeType.LiteralString) {
                string groupingSize = (string)(QilLiteral)result;

                // NOTE: It is unclear from the spec what we should do with float numbers here.
                // Let's apply XPath number and round functions as usual, suppressing any conversion errors.
                double dblGroupingSize = XsltFunctions.Round(XPathConvert.StringToDouble(groupingSize));
                if (0 <= dblGroupingSize && dblGroupingSize <= int.MaxValue) {
                    return f.Double(dblGroupingSize);
                }
                // NaN goes here as well
                return f.Double(0);
            } else {
                // NOTE: We should have the same checks for both compile time and execution time
                QilIterator i = f.Let(f.ConvertToNumber(result));
                return f.Loop(i,
                    f.Conditional(f.And(f.Lt(f.Double(0), i), f.Lt(i, f.Double(int.MaxValue))),
                        i,
                        f.Double(0)
                    )
                );
            }
        }

        private QilNode CompileNumber(Number num) {
            QilNode value;

            if (num.Value != null) {
                // 

                value = f.ConvertToNumber(CompileXPathExpression(num.Value));
            } else {
                QilNode countPattern = (num.Count != null) ? CompileNumberPattern(num.Count) : null;
                QilNode fromPattern  = (num.From  != null) ? CompileNumberPattern(num.From ) : null;

                switch (num.Level) {
                case NumberLevel.Single   : value = PlaceMarker(countPattern, fromPattern, false); break;
                case NumberLevel.Multiple : value = PlaceMarker(countPattern, fromPattern, true ); break;
                default:
                    Debug.Assert(num.Level == NumberLevel.Any);
                    value = PlaceMarkerAny(countPattern, fromPattern);
                    break;
                }
            }

            bool fwdCompat = num.ForwardsCompatible;
            return f.TextCtor(f.InvokeNumberFormat(
                value, CompileStringAvt(num.Format),
                CompileLangAttributeToLcid       (num.Lang,              fwdCompat),
                CompileLetterValueAttribute      (num.LetterValue,       fwdCompat),
                CompileGroupingSeparatorAttribute(num.GroupingSeparator, fwdCompat),
                CompileGroupingSizeAttribute     (num.GroupingSize,      fwdCompat)
            ));
        }

        // ------------- CompileAndSortMatchPatterns() -------------

        private void CompileAndSortMatches(Stylesheet sheet) {
            Debug.Assert(sheet.TemplateMatches.Count == 0);

            foreach (Template template in sheet.Templates) {
                if (template.Match != null) {
                    EnterScope(template);
                    QilNode result = CompileMatchPattern(template.Match);
                    if (result.NodeType == QilNodeType.Sequence) {
                        QilList filters = (QilList)result;
                        for (int idx = 0; idx < filters.Count; idx++) {
                            sheet.AddTemplateMatch(template, (QilLoop)filters[idx]);
                        }
                    } else {
                        sheet.AddTemplateMatch(template, (QilLoop)result);
                    }
                    ExitScope();
                }
            }

            sheet.SortTemplateMatches();

            foreach (Stylesheet import in sheet.Imports) {
                CompileAndSortMatches(import);
            }
        }

        // ------------- CompileKeys() -------------

        private void CompileKeys() {
            CheckSingletonFocus();
            for (int idx = 0; idx < compiler.Keys.Count; idx++) {
                foreach (Key key in compiler.Keys[idx]) {
                    EnterScope(key);
                    QilParameter context = f.Parameter(T.NodeNotRtf);
                    singlFocus.SetFocus(context);
                    QilIterator values  = f.For(f.OptimizeBarrier(CompileKeyMatch(key.Match)));
                    singlFocus.SetFocus(values);
                    QilIterator keys = f.For(CompileKeyUse(key));
                    keys = f.For(f.OptimizeBarrier(f.Loop(keys, f.ConvertToString(keys))));

                    QilParameter value = f.Parameter(T.StringX);

                    QilFunction func = f.Function(f.FormalParameterList(context, value),
                        f.Filter(values,
                            f.Not(f.IsEmpty(f.Filter(keys, f.Eq(keys, value))))
                        ),
                        f.False()
                    );

                    func.DebugName = key.GetDebugName();
                    SetLineInfo(func, key.SourceLine);
                    key.Function = func;
                    this.functions.Add(func);
                    ExitScope();
                }
            }
            singlFocus.SetFocus(null);
        }

        // ---------------------- Global variables and parameters -----------------------

        private void CreateGlobalVarPars() {
            foreach (VarPar par in compiler.ExternalPars) {
                CreateGlobalVarPar(par);
            }
            foreach (VarPar var in compiler.GlobalVars) {
                CreateGlobalVarPar(var);
            }
        }

        private void CreateGlobalVarPar(VarPar varPar) {
            Debug.Assert(varPar.NodeType == XslNodeType.Variable || varPar.NodeType == XslNodeType.Param);
            XmlQueryType xt = ChooseBestType(varPar);
            QilIterator it;
            if (varPar.NodeType == XslNodeType.Variable) {
                it = f.Let(f.Unknown(xt));
            } else {
                it = f.Parameter(null, varPar.Name, xt);
            }
            it.DebugName = varPar.Name.ToString();
            varPar.Value = it;
            SetLineInfo(it, varPar.SourceLine);
            scope.AddVariable(varPar.Name, it);
        }

        private void CompileGlobalVariables() {
            CheckSingletonFocus();
            singlFocus.SetFocus(SingletonFocusType.InitialDocumentNode);

            foreach (VarPar par in compiler.ExternalPars) {
                extPars.Add(CompileGlobalVarPar(par));
            }
            foreach (VarPar var in compiler.GlobalVars) {
                gloVars.Add(CompileGlobalVarPar(var));
            }

            singlFocus.SetFocus(null);
        }

        private QilIterator CompileGlobalVarPar(VarPar varPar) {
            Debug.Assert(varPar.NodeType == XslNodeType.Variable || varPar.NodeType == XslNodeType.Param);
            QilIterator it = (QilIterator)varPar.Value;

            QilList nsList = EnterScope(varPar);
            QilNode content = CompileVarParValue(varPar);
            SetLineInfo(content, it.SourceLine);
            content = AddCurrentPositionLast(content);
            content = SetDebugNs(content, nsList);
            it.SourceLine = SourceLineInfo.NoSource;
            it.Binding = content;
            ExitScope();
            return it;
        }

        // ------------- CompileXPathExpression() / CompileMatchPattern() / CompileKeyPattern() -----------

        private void ReportErrorInXPath(XslLoadException e) {
            XPathCompileException ex = e as XPathCompileException;
            string errorText = (ex != null) ? ex.FormatDetailedMessage() : e.Message;
            compiler.ReportError(lastScope.SourceLine, Res.Xml_UserException, errorText);
        }

        private QilNode PhantomXPathExpression() {
            return f.TypeAssert(f.Sequence(), T.ItemS);
        }

        private QilNode PhantomKeyMatch() {
            return f.TypeAssert(f.Sequence(), T.NodeNotRtfS);
        }

        // Calls to CompileXPathExpression() can't be nested in the XSLT. So we can reuse the same instance of xpathBuilder.
        // The only thing we need to do before its use is adjustment of IXPathEnvironment to have correct context tuple.
        private QilNode CompileXPathExpression(string expr) {
            XPathScanner    scanner;
            QilNode         result;

            SetEnvironmentFlags(/*allowVariables:*/true, /*allowCurrent:*/true, /*allowKey:*/true);
            if (expr == null) {
                result = PhantomXPathExpression();
            } else {
                try {
                    // Note that the constructor may throw an exception, for example, in case of the expression "'"
                    scanner = new XPathScanner(expr);
                    result = xpathParser.Parse(scanner, xpathBuilder, LexKind.Eof);
                } catch (XslLoadException e) {
                    if (xslVersion != XslVersion.ForwardsCompatible) {
                        ReportErrorInXPath(/*[XT0300]*/e);
                    }
                    result = f.Error(f.String(e.Message));
                }
            }
            if (result is QilIterator) {
                result = f.Nop(result);
            }
            return result;
        }

        private QilNode CompileNodeSetExpression(string expr) {
            QilNode result = f.TryEnsureNodeSet(CompileXPathExpression(expr));
            if (result == null) {
                // The expression is never a node-set
                XPathCompileException e = new XPathCompileException(expr, 0, expr.Length, Res.XPath_NodeSetExpected, null);
                if (xslVersion != XslVersion.ForwardsCompatible) {
                    ReportErrorInXPath(/*[XTTE_101]*/e);
                }
                result = f.Error(f.String(e.Message));
            }
            return result;
        }

        private QilNode CompileXPathExpressionWithinAvt(string expr, ref int pos) {
            Debug.Assert(expr != null);
            XPathScanner    scanner;
            QilNode         result;
            int             startPos = pos;

            SetEnvironmentFlags(/*allowVariables:*/true, /*allowCurrent:*/true, /*allowKey:*/true);
            try {
                scanner = new XPathScanner(expr, pos);
                result = xpathParser.Parse(scanner, xpathBuilder, LexKind.RBrace);
                pos = scanner.LexStart + 1;
            } catch (XslLoadException e) {
                if (xslVersion != XslVersion.ForwardsCompatible) {
                    ReportErrorInXPath(/*[XT0350][XT0360]*/e);
                }
                result = f.Error(f.String(e.Message));
                pos = expr.Length;
            }
            if (result is QilIterator) {
                result = f.Nop(result);
            }
            return result;
        }

        private QilNode CompileMatchPattern(string pttrn) {
            Debug.Assert(pttrn != null);
            XPathScanner    scanner;
            QilNode         result;

            SetEnvironmentFlags(/*allowVariables:*/false, /*allowCurrent:*/false, /*allowKey:*/true);
            try {
                scanner = new XPathScanner(pttrn);
                result = ptrnParser.Parse(scanner, ptrnBuilder);
            } catch (XslLoadException e) {
                if (xslVersion != XslVersion.ForwardsCompatible) {
                    ReportErrorInXPath(/*[XT0340]*/e);
                }
                result = f.Loop(f.For(ptrnBuilder.FixupNode),
                    f.Error(f.String(e.Message))
                );
                XPathPatternBuilder.SetPriority(result, 0.5);
            }
            return result;
        }

        private QilNode CompileNumberPattern(string pttrn) {
            Debug.Assert(pttrn != null);
            XPathScanner    scanner;
            QilNode         result;

            SetEnvironmentFlags(/*allowVariables:*/true, /*allowCurrent:*/false, /*allowKey:*/true);
            try {
                scanner = new XPathScanner(pttrn);
                result = ptrnParser.Parse(scanner, ptrnBuilder);
            } catch (XslLoadException e) {
                if (xslVersion != XslVersion.ForwardsCompatible) {
                    ReportErrorInXPath(/*[XT0340]*/e);
                }
                result = f.Error(f.String(e.Message));
            }
            return result;
        }

        private QilNode CompileKeyMatch(string pttrn) {
            XPathScanner    scanner;
            QilNode         result;

            if (keyMatchBuilder == null) {
                keyMatchBuilder = new KeyMatchBuilder((IXPathEnvironment) this);
            }
            SetEnvironmentFlags(/*allowVariables:*/false, /*allowCurrent:*/false, /*allowKey:*/false);
            if (pttrn == null) {
                result = PhantomKeyMatch();
            } else {
                try {
                    scanner = new XPathScanner(pttrn);
                    result = ptrnParser.Parse(scanner, keyMatchBuilder);
                } catch (XslLoadException e) {
                    if (xslVersion != XslVersion.ForwardsCompatible) {
                        ReportErrorInXPath(/*[XT0340]*/e);
                    }
                    result = f.Error(f.String(e.Message));
                }
            }
            return result;
        }

        private QilNode CompileKeyUse(Key key) {
            string          expr = key.Use;
            XPathScanner    scanner;
            QilNode         result;

            SetEnvironmentFlags(/*allowVariables:*/false, /*allowCurrent:*/true, /*allowKey:*/false);
            if (expr == null) {
                result = f.Error(f.String(XslLoadException.CreateMessage(key.SourceLine, Res.Xslt_MissingAttribute, "use")));
            } else {
                try {
                    scanner = new XPathScanner(expr);
                    result = xpathParser.Parse(scanner, xpathBuilder, LexKind.Eof);
                } catch (XslLoadException e) {
                    if (xslVersion != XslVersion.ForwardsCompatible) {
                        ReportErrorInXPath(/*[XT0300]*/e);
                    }
                    result = f.Error(f.String(e.Message));
                }
            }
            if (result is QilIterator) {
                result = f.Nop(result);
            }
            return result;
        }

        private QilNode ResolveQNameDynamic(bool ignoreDefaultNs, QilNode qilName) {
            f.CheckString(qilName);
            QilList nsDecls = f.BaseFactory.Sequence();
            if (ignoreDefaultNs) {
                nsDecls.Add(f.NamespaceDecl(f.String(string.Empty), f.String(string.Empty)));
            }
            foreach (ScopeRecord rec in this.scope) {
                string recPrefix = rec.ncName;
                string recNsUri  = rec.nsUri;

                if (ignoreDefaultNs && recPrefix.Length == 0) {
                    // Do not take into account the default namespace
                } else {
                    nsDecls.Add(f.NamespaceDecl(f.String(recPrefix), f.String(recNsUri)));
                }
            }
            return f.StrParseQName(qilName, nsDecls);
        }

        // ----------------- apply-templates, apply-imports ----------------------------- //

        private QilNode GenerateApply(StylesheetLevel sheet, XslNode node) {
            Debug.Assert(
                node.NodeType == XslNodeType.ApplyTemplates && sheet is RootLevel ||
                node.NodeType == XslNodeType.ApplyImports   && sheet is Stylesheet
            );

            if (compiler.Settings.CheckOnly) {
                return f.Sequence();
            }
            return InvokeApplyFunction(sheet, /*mode:*/node.Name, node.Content);
        }

        private void SetArg(IList<XslNode> args, int pos, QilName name, QilNode value) {
            VarPar varPar;
            if (args.Count <= pos || args[pos].Name != name) {
                varPar = AstFactory.WithParam(name);
                args.Insert(pos, varPar); 
            } else {
                varPar = (VarPar) args[pos];
            }
            varPar.Value = value;
        }
        private IList<XslNode> AddRemoveImplicitArgs(IList<XslNode> args, XslFlags flags) {
            //We currently don't reuse the same argument list. So remove is not needed and will not work in this code
            if (IsDebug) {
                flags = XslFlags.FullFocus;
            }
            if ((flags & XslFlags.FocusFilter) != 0) {
                if (args == null || args.IsReadOnly) {
                    args = new List<XslNode>(3);
                }
                int pos = 0;
                if ((flags & XslFlags.Current ) != 0) { SetArg(args, pos ++, nameCurrent , GetCurrentNode    ()); } 
                if ((flags & XslFlags.Position) != 0) { SetArg(args, pos ++, namePosition, GetCurrentPosition()); } 
                if ((flags & XslFlags.Last    ) != 0) { SetArg(args, pos ++, nameLast    , GetLastPosition   ()); } 
            }
            return args;
        }

        // Fills invokeArgs with values from actualArgs in order given by formalArgs
        // Returns true if formalArgs maps 1:1 with actual args.
        // Formaly this is n*n algorithm. We can optimize it by calculationg "signature"
        // of the function as sum of all hashes of its args names.
        private bool FillupInvokeArgs(IList<QilNode> formalArgs, IList<XslNode> actualArgs, QilList invokeArgs) {
            if (actualArgs.Count != formalArgs.Count) {
                return false;
            }
            invokeArgs.Clear();
            for (int invArg = 0; invArg < formalArgs.Count; invArg++) {
                QilName formalArgName = ((QilParameter)formalArgs[invArg]).Name;
                XmlQueryType paramType = formalArgs[invArg].XmlType;
                QilNode arg = null; {
                    for (int actArg = 0; actArg < actualArgs.Count; actArg++) {
                        Debug.Assert(actualArgs[actArg].NodeType == XslNodeType.WithParam, "All Sorts was removed in CompileSorts()");
                        VarPar withParam = (VarPar)actualArgs[actArg];
                        if (formalArgName.Equals(withParam.Name)) {
                            QilNode value = withParam.Value;
                            XmlQueryType valueType = value.XmlType;
                            if (valueType != paramType) {
                                if (valueType.IsNode && paramType.IsNode && valueType.IsSubtypeOf(paramType)) {
                                    // We can pass it
                                } else {
                                    // Formal argument has the same name but a different type
                                    return false;
                                }
                            }
                            arg = value;
                            break;
                        }
                    }
                }
                if (arg == null) {
                    // Formal argument has not been found among actual arguments
                    return false;
                }
                invokeArgs.Add(arg);
            }
            // All arguments have been found
            return true;
        }

        private QilNode InvokeApplyFunction(StylesheetLevel sheet, QilName mode, IList<XslNode> actualArgs) {
            // Here we create function that has one argument for each with-param in apply-templates
            // We have actualArgs -- list of xsl:with-param(name, value)
            // From it we create:
            // invokeArgs -- values to use with QilInvoke
            // formalArgs -- list of iterators to use with QilFunction
            // actualArgs -- modify it to hold iterators (formalArgs) instead of values to ise in invoke generator inside function budy

            XslFlags flags; { 
                if (! sheet.ModeFlags.TryGetValue(mode, out flags)) {
                    flags = 0;
                }
                flags |= XslFlags.Current; // Due to recursive nature of Apply(Templates/Imports) we will need current node any way
            }
            actualArgs = AddRemoveImplicitArgs(actualArgs, flags);

            QilList     invokeArgs = f.ActualParameterList();
            QilFunction applyFunction = null;

            // Look at the list of all functions that have been already built.  If a suitable one is found, reuse it.
            List<QilFunction> functionsForMode;
            if (!sheet.ApplyFunctions.TryGetValue(mode, out functionsForMode)) {
                functionsForMode = sheet.ApplyFunctions[mode] = new List<QilFunction>();
            }

            foreach (QilFunction func in functionsForMode) {
                if (FillupInvokeArgs(func.Arguments, actualArgs, /*ref*/invokeArgs)) {
                    applyFunction = func;
                    break;
                }
            }

            // If a suitable function has not been found, create it
            if (applyFunction == null) {
                invokeArgs.Clear();
                // We wasn't able to find suitable function. Let's build new:
                // 1. Function arguments
                QilList formalArgs = f.FormalParameterList();
                for (int i = 0; i < actualArgs.Count; i++) {
                    Debug.Assert(actualArgs[i].NodeType == XslNodeType.WithParam, "All Sorts was removed in CompileSorts()");
                    VarPar withParam = (VarPar)actualArgs[i] ;

                    // Add actual arg to 'invokeArgs' array. No need to clone it since it must be
                    // a literal or a reference.
                    invokeArgs.Add(withParam.Value);

                    // Create correspondent formal arg
                    QilParameter formalArg = f.Parameter(i == 0 ? T.NodeNotRtf : withParam.Value.XmlType);
                    formalArg.Name = CloneName(withParam.Name);
                    formalArgs.Add(formalArg);

                    // Change actual arg value to formalArg for reuse in calling built-in templates rules
                    withParam.Value = formalArg;
                }

                // 2. Function header
                applyFunction = f.Function(formalArgs,
                    f.Boolean((flags & XslFlags.SideEffects) != 0),
                    T.NodeNotRtfS
                );
                string attMode = (mode.LocalName.Length == 0) ? string.Empty : " mode=\"" + mode.QualifiedName + '"';
                applyFunction.DebugName = (sheet is RootLevel ? "<xsl:apply-templates" : "<xsl:apply-imports") + attMode + '>';
                functionsForMode.Add(applyFunction);
                this.functions.Add(applyFunction);

                // 3. Function body
                Debug.Assert(actualArgs[0].Name == nameCurrent, "Caller should always pass $current as a first argument to apply-* calls.");
                QilIterator current = (QilIterator)formalArgs[0];

                // 3.1 Built-in templates:
                // 3.1.1 loop over content of current element
                QilLoop loopOnContent; {
                    QilIterator iChild = f.For(f.Content(current));
                    QilNode filter = f.Filter(iChild, f.IsType(iChild, T.Content));
                    filter.XmlType = T.ContentS;    // not attribute

                    LoopFocus curLoopSaved = curLoop;
                    curLoop.SetFocus(f.For(filter));

                    /* Prepare actual arguments */
                    // At XSLT 1.0, if a built-in template rule is invoked with parameters, the parameters are not
                    // passed on to any templates invoked by the built-in rule. At XSLT 2.0, these parameters are
                    // passed through the built-in template rule unchanged.

                    // we can't just modify current/position/last of actualArgs in XSLT 2.0 as we tried before, 
                    // becuase flags for apply-import amy now be different then flags for apply-templates, so 
                    // we may need to add some space for additional position/last arguments
                    QilNode body = InvokeApplyFunction(compiler.Root, mode, /*actualArgs:*/null);
                    if (IsDebug) {
                        body = f.Sequence(InvokeOnCurrentNodeChanged(), body);
                    }
                    loopOnContent = curLoop.ConstructLoop(body);
                    curLoop = curLoopSaved;
                }

                // 3.1.2 switch on type of current node
                QilTernary builtinTemplates = f.BaseFactory.Conditional(f.IsType(current, elementOrDocumentType),                    
                    loopOnContent,
                    f.Conditional(f.IsType(current, textOrAttributeType),
                        f.TextCtor(f.XPathNodeValue(current)),
                        f.Sequence()
                    )
                );

                // 3.2 Stylesheet templates
                matcherBuilder.CollectPatterns(sheet, mode);
                applyFunction.Definition = matcherBuilder.BuildMatcher(current, actualArgs, /*otherwise:*/builtinTemplates);
            }
            return f.Invoke(applyFunction, invokeArgs);
        }

        // -------------------------------- IErrorHelper --------------------------------

        public void ReportError(string res, params string[] args) {
            compiler.ReportError(lastScope.SourceLine, res, args);
        }

        public void ReportWarning(string res, params string[] args) {
            compiler.ReportWarning(lastScope.SourceLine, res, args);
        }

        // ------------------------------------------------------------------------------

        [Conditional("DEBUG")]
        private void VerifyXPathQName(QilName qname) {
            Debug.Assert(
                compiler.IsPhantomName(qname) ||
                qname.NamespaceUri == ResolvePrefix(/*ignoreDefaultNs:*/true, qname.Prefix),
                "QilGenerator must resolve the prefix to the same namespace as XsltLoader"
            );
        }

        private string ResolvePrefix(bool ignoreDefaultNs, string prefix) {
            if (ignoreDefaultNs && prefix.Length == 0) {
                return string.Empty;
            } else {
                string ns = scope.LookupNamespace(prefix);
                if (ns == null) {
                    if (prefix.Length == 0) {
                        ns = string.Empty;
                    } else {
                        ReportError(/*[XT0280]*/Res.Xslt_InvalidPrefix, prefix);
                        ns = compiler.CreatePhantomNamespace();
                    }
                }
                return ns;
            }
        }

        private void SetLineInfoCheck(QilNode n, ISourceLineInfo lineInfo) {
            // Prevent xsl:choose override xsl:when, etc.
            if (n.SourceLine == null) {
                SetLineInfo(n, lineInfo);
            } else {
                Debug.Assert(!IsDebug, "Attempt to override SourceLineInfo in debug mode");
            }
        }

        private static QilNode SetLineInfo(QilNode n, ISourceLineInfo lineInfo) {
            Debug.Assert(n.SourceLine == null);
            if (lineInfo != null) {
                SourceLineInfo.Validate(lineInfo);
                if (0 < lineInfo.Start.Line && lineInfo.Start.LessOrEqual(lineInfo.End)) {
                    n.SourceLine = lineInfo;
                }
            }
            return n;
        }

        private QilNode AddDebugVariable(QilName name, QilNode value, QilNode content) {
            QilIterator var = f.Let(value);
            var.DebugName = name.ToString();
            return f.Loop(var, content);
        }

        private QilNode SetDebugNs(QilNode n, QilList nsList) {
            if (n != null && nsList != null) {
                QilNode nsVar = GetNsVar(nsList);
                Debug.Assert(nsVar.XmlType.IsSubtypeOf(T.NamespaceS));
                if (nsVar.XmlType.Cardinality == XmlQueryCardinality.One) {
                    // We want CLR type to be XmlQuerySequence instead of XPathNavigator
                    nsVar = f.TypeAssert(nsVar, T.NamespaceS);
                }
                n = AddDebugVariable(CloneName(nameNamespaces), nsVar, n);
            }
            return n;
        }

        private QilNode AddCurrentPositionLast(QilNode content) {
            if (IsDebug) {
                content = AddDebugVariable(CloneName(nameLast)    , GetLastPosition   (), content);
                content = AddDebugVariable(CloneName(namePosition), GetCurrentPosition(), content);
                content = AddDebugVariable(CloneName(nameCurrent) , GetCurrentNode    (), content);
            }
            return content;
        }

        private QilName CloneName(QilName name) {
            return (QilName)name.ShallowClone(f.BaseFactory);
        }

        // This helper internal class is used for compiling sort's and with-param's
        private class VariableHelper {
            private Stack<QilIterator>  vars = new Stack<QilIterator>();
            private XPathQilFactory     f;

            public VariableHelper(XPathQilFactory f) {
                this.f = f;
            }

            public int StartVariables() {
                return vars.Count;
            }

            public void AddVariable(QilIterator let) {
                Debug.Assert(let.NodeType == QilNodeType.Let);
                vars.Push(let);
            }

            public QilNode FinishVariables(QilNode node, int varScope) {
                Debug.Assert(0 <= varScope && varScope <= vars.Count);
                for (int i = vars.Count - varScope; i-- != 0; ) {
                    node = f.Loop(vars.Pop(), node);
                }
                return node;
            }

            [Conditional("DEBUG")]
            public void CheckEmpty() {
                Debug.Assert(vars.Count == 0, "Accumulated variables left unclaimed");
            }
        }
    }
}