The Labs \ Source Viewer \ SSCLI \ System.Xml.Xsl.Xslt \ QilGenerator

  1. //------------------------------------------------------------------------------
  2. // <copyright file="QilGenerator.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. // <spec>http://www.w3.org/TR/xslt.html</spec>
  15. // <spec>http://www.w3.org/TR/xslt20/</spec>
  16. //------------------------------------------------------------------------------
  17. using System.Collections;
  18. using System.Collections.Generic;
  19. using System.Collections.Specialized;
  20. using System.Diagnostics;
  21. using System.Text;
  22. using System.Xml.Xsl.Qil;
  23. using System.Xml.Xsl.Runtime;
  24. using System.Xml.Xsl.XPath;
  25. namespace System.Xml.Xsl.Xslt
  26. {
  27.     using Res = System.Xml.Utils.Res;
  28.     using ScopeRecord = CompilerScopeManager<QilIterator>.ScopeRecord;
  29.     using T = XmlQueryTypeFactory;
  30.    
  31.     // Everywhere in this code in case of error in the stylesheet we should call ReportError or ReportWarning
  32.    
  33.     internal class ReferenceReplacer : QilReplaceVisitor
  34.     {
  35.         private QilReference lookFor, replaceBy;
  36.        
  37.         public ReferenceReplacer(QilFactory f) : base(f)
  38.         {
  39.         }
  40.        
  41.         public QilNode Replace(QilNode expr, QilReference lookFor, QilReference replaceBy)
  42.         {
  43.             this.lookFor = lookFor;
  44.             this.replaceBy = replaceBy;
  45.             return VisitAssumeReference(expr);
  46.         }
  47.        
  48.         protected override QilNode VisitReference(QilNode n)
  49.         {
  50.             return (n == lookFor) ? replaceBy : n;
  51.         }
  52.     }
  53.    
  54.     internal partial class QilGenerator : IErrorHelper
  55.     {
  56.         private CompilerScopeManager<QilIterator> scope;
  57.         private OutputScopeManager outputScope;
  58.         private HybridDictionary prefixesInUse;
  59.        
  60.         private XsltQilFactory f;
  61.         private XPathBuilder xpathBuilder;
  62.         private XPathParser<QilNode> xpathParser;
  63.         private XPathPatternBuilder ptrnBuilder;
  64.         private XPathPatternParser ptrnParser;
  65.         private ReferenceReplacer refReplacer;
  66.         private KeyMatchBuilder keyMatchBuilder;
  67.         private InvokeGenerator invkGen;
  68.         private MatcherBuilder matcherBuilder;
  69.         private QilStrConcatenator strConcat;
  70.         private VariableHelper varHelper;
  71.        
  72.         private Compiler compiler;
  73.         private QilList functions;
  74.         private QilFunction generalKey;
  75.         private bool formatNumberDynamicUsed;
  76.         private QilList extPars;
  77.         private QilList gloVars;
  78.         private QilList nsVars;
  79.        
  80.         private XmlQueryType elementOrDocumentType;
  81.         private XmlQueryType textOrAttributeType;
  82.         private XslNode lastScope;
  83.         private XslVersion xslVersion;
  84.        
  85.         private QilName nameCurrent;
  86.         private QilName namePosition;
  87.         private QilName nameLast;
  88.         private QilName nameNamespaces;
  89.        
  90.         private SingletonFocus singlFocus;
  91.         private FunctionFocus funcFocus;
  92.         private LoopFocus curLoop;
  93.        
  94.         private int formatterCnt;
  95.        
  96.         public static QilExpression CompileStylesheet(Compiler compiler)
  97.         {
  98.             return new QilGenerator(compiler.IsDebug).Compile(compiler);
  99.         }
  100.        
  101.         private QilGenerator(bool debug)
  102.         {
  103.             scope = new CompilerScopeManager<QilIterator>();
  104.             outputScope = new OutputScopeManager();
  105.             prefixesInUse = new HybridDictionary();
  106.             f = new XsltQilFactory(new QilFactory(), debug);
  107.             xpathBuilder = new XPathBuilder((IXPathEnvironment)this);
  108.             xpathParser = new XPathParser<QilNode>();
  109.             ptrnBuilder = new XPathPatternBuilder((IXPathEnvironment)this);
  110.             ptrnParser = new XPathPatternParser();
  111.             refReplacer = new ReferenceReplacer(f.BaseFactory);
  112.             invkGen = new InvokeGenerator(f, debug);
  113.             matcherBuilder = new MatcherBuilder(f, refReplacer, invkGen);
  114.             singlFocus = new SingletonFocus(f);
  115.             funcFocus = new FunctionFocus();
  116.             curLoop = new LoopFocus(f);
  117.             strConcat = new QilStrConcatenator(f);
  118.             varHelper = new VariableHelper(f);
  119.            
  120.             elementOrDocumentType = T.DocumentOrElement;
  121.             textOrAttributeType = T.NodeChoice(XmlNodeKindFlags.Text | XmlNodeKindFlags.Attribute);
  122.            
  123.             nameCurrent = f.QName("current", XmlReservedNs.NsXslDebug);
  124.             namePosition = f.QName("position", XmlReservedNs.NsXslDebug);
  125.             nameLast = f.QName("last", XmlReservedNs.NsXslDebug);
  126.             nameNamespaces = f.QName("namespaces", XmlReservedNs.NsXslDebug);
  127.            
  128.             formatterCnt = 0;
  129.         }
  130.        
  131.         private bool IsDebug {
  132.             get { return compiler.IsDebug; }
  133.         }
  134.        
  135.         private bool EvaluateFuncCalls {
  136.             get { return !IsDebug; }
  137.         }
  138.         private bool InferXPathTypes {
  139.             get { return !IsDebug; }
  140.         }
  141.        
  142.         private QilExpression Compile(Compiler compiler)
  143.         {
  144.             Debug.Assert(compiler != null);
  145.             this.compiler = compiler;
  146.             this.functions = f.FunctionList();
  147.             this.extPars = f.GlobalParameterList();
  148.             this.gloVars = f.GlobalVariableList();
  149.             this.nsVars = f.GlobalVariableList();
  150.            
  151.             compiler.Scripts.CompileScripts();
  152.            
  153.             if (!IsDebug) {
  154.                 (new XslAstAnalyzer()).Analyze(compiler);
  155.             }
  156.            
  157.             // Global variables and external params are visible from everywhere, so we have
  158.             // to prepopulate the scope with all of them before starting compilation
  159.             CreateGlobalVarPars();
  160.            
  161.             try {
  162.                 CompileKeys();
  163.                 CompileAndSortMatches(compiler.PrincipalStylesheet);
  164.                 PrecompileProtoTemplatesHeaders();
  165.                 CompileGlobalVariables();
  166.                
  167.                 foreach (ProtoTemplate tmpl in compiler.AllTemplates) {
  168.                     CompileProtoTemplate(tmpl);
  169.                 }
  170.                 varHelper.CheckEmpty();
  171.             }
  172.             catch (XslLoadException e) {
  173.                 e.SetSourceLineInfo(lastScope.SourceLine);
  174.                 throw;
  175.             }
  176.             catch (Exception e) {
  177.                 if (!XmlException.IsCatchableException(e)) {
  178.                     throw;
  179.                 }
  180.                 throw new XslLoadException(e, lastScope.SourceLine);
  181.             }
  182.            
  183.             QilNode root = CompileRootExpression(compiler.StartApplyTemplates);
  184.            
  185.             // Clean default values which we calculate in caller context
  186.             foreach (ProtoTemplate tmpl in compiler.AllTemplates) {
  187.                 foreach (QilParameter par in tmpl.Function.Arguments) {
  188.                     if (!IsDebug || par.Name.Equals(nameNamespaces)) {
  189.                         par.DefaultValue = null;
  190.                     }
  191.                 }
  192.             }
  193.            
  194.             QilExpression qil = f.QilExpression(root, f.BaseFactory);
  195.             {
  196.                 qil.FunctionList = functions;
  197.                 qil.GlobalParameterList = extPars;
  198.                 qil.GlobalVariableList = gloVars;
  199.                 qil.WhitespaceRules = compiler.WhitespaceRules;
  200.                 qil.IsDebug = IsDebug;
  201.                 qil.DefaultWriterSettings = compiler.Output.Settings;
  202.             }
  203.            
  204.             return qil;
  205.         }
  206.        
  207.         [Conditional("DEBUG")]
  208.         private void CheckSingletonFocus()
  209.         {
  210.             Debug.Assert(!curLoop.IsFocusSet && !funcFocus.IsFocusSet, "Must be compiled using singleton focus");
  211.         }
  212.        
  213.         private QilNode CompileRootExpression(XslNode applyTmpls)
  214.         {
  215.             QilNode init = f.Int32(0);
  216.            
  217.             // Register all decimal formats, they are needed for format-number()
  218.             if (formatNumberDynamicUsed || IsDebug) {
  219.                 foreach (DecimalFormatDecl format in compiler.DecimalFormats) {
  220.                     init = f.Add(init, f.InvokeRegisterDecimalFormat(format));
  221.                 }
  222.             }
  223.            
  224.             // Register all script namespaces
  225.             foreach (string scriptNs in compiler.Scripts.ScriptClasses.Keys) {
  226.                 init = f.Add(init, f.InvokeCheckScriptNamespace(scriptNs));
  227.             }
  228.            
  229.             // Compile start apply-templates call
  230.             CheckSingletonFocus();
  231.             singlFocus.SetFocus(SingletonFocusType.InitialContextNode);
  232.             QilNode result = GenerateApply((Stylesheet)null, applyTmpls);
  233.             singlFocus.SetFocus(null);
  234.            
  235.             // Prevent optimizing initialization out
  236.             if (init.NodeType == QilNodeType.Add) {
  237.                 result = f.Conditional(f.Eq(init, f.Int32(0)), result, f.Sequence());
  238.             }
  239.             return f.DocumentCtor(result);
  240.         }
  241.        
  242.         private QilList EnterScope(XslNode node)
  243.         {
  244.             // This is the only place where lastScope is changed
  245.             lastScope = node;
  246.             xslVersion = node.XslVersion;
  247.             this.scope.PushScope();
  248.            
  249.             bool hasNamespaces = false;
  250.             NsDecl nsDecl = node.Namespaces;
  251.             while (nsDecl != null) {
  252.                 Debug.Assert(nsDecl.NsUri != null);
  253.                 this.scope.AddNamespace(nsDecl.Prefix, nsDecl.NsUri);
  254.                 nsDecl = nsDecl.Prev;
  255.                 hasNamespaces = true;
  256.             }
  257.             if (hasNamespaces) {
  258.                 return BuildDebuggerNamespaces();
  259.             }
  260.             return null;
  261.         }
  262.        
  263.         private void ExitScope()
  264.         {
  265.             this.scope.PopScope();
  266.         }
  267.        
  268.         private QilList BuildDebuggerNamespaces()
  269.         {
  270.             if (IsDebug) {
  271.                 QilList nsDecls = f.BaseFactory.Sequence();
  272.                 foreach (ScopeRecord rec in this.scope) {
  273.                     nsDecls.Add(f.NamespaceDecl(f.String(rec.ncName), f.String(rec.nsUri)));
  274.                 }
  275.                 return nsDecls;
  276.             }
  277.             return null;
  278.         }
  279.        
  280.         // For each call instruction - call-template, use-attribute-sets, apply-template, apply-imports - we have
  281.         // to pass the current execution context which may be represented as three additional implicit arguments:
  282.         // current, position, last. In most cases the last two ones are never used, so for the purpose
  283.         // of optimization in non-debug mode we bind them only if they are actually needed.
  284.        
  285.         // Strictly speaking, a (proto)template function is supplied with the additional position argument if both
  286.         // the following conditions are true:
  287.         // 1. At least one template within the given stylesheet contains a "naked" position() function invocation
  288.         // (needPositionArgs == true). Naked here means "not within any of for-each instructions".
  289.         // 2. THIS template contains a naked position() invocation or a naked call-template, use-attribute-sets,
  290.         // or apply-imports instruction. Note: apply-template's are not taken into account because in that
  291.         // case the call will be actually wrapped in a tuple.
  292.         //
  293.         // The same is true for additional last arguments.
  294.        
  295.         // There are 3 cases when context methods may be called:
  296.         // 1. In context of for-each expression
  297.         // 2. In context of template
  298.         // 3. In context of global variable
  299.         // We treating this methods differentely when they are called to create implicit arguments.
  300.         // Implicite argument (position, last) are rare and lead to uneficiant code. So we treating them
  301.         // specialy to be able eliminate them later, wen we compiled everithing and can detect was they used or not.
  302.        
  303.         // Returns context node
  304.         private QilNode GetCurrentNode()
  305.         {
  306.             if (curLoop.IsFocusSet) {
  307.                 return curLoop.GetCurrent();
  308.             }
  309.             else if (funcFocus.IsFocusSet) {
  310.                 return funcFocus.GetCurrent();
  311.             }
  312.             else {
  313.                 return singlFocus.GetCurrent();
  314.             }
  315.         }
  316.        
  317.         // Returns context position
  318.         private QilNode GetCurrentPosition()
  319.         {
  320.             if (curLoop.IsFocusSet) {
  321.                 return curLoop.GetPosition();
  322.             }
  323.             else if (funcFocus.IsFocusSet) {
  324.                 return funcFocus.GetPosition();
  325.             }
  326.             else {
  327.                 return singlFocus.GetPosition();
  328.             }
  329.         }
  330.        
  331.         // Returns context size
  332.         private QilNode GetLastPosition()
  333.         {
  334.             if (curLoop.IsFocusSet) {
  335.                 return curLoop.GetLast();
  336.             }
  337.             else if (funcFocus.IsFocusSet) {
  338.                 return funcFocus.GetLast();
  339.             }
  340.             else {
  341.                 return singlFocus.GetLast();
  342.             }
  343.         }
  344.        
  345.         private XmlQueryType ChooseBestType(VarPar var)
  346.         {
  347.             if (IsDebug || !InferXPathTypes) {
  348.                 return T.ItemS;
  349.             }
  350.            
  351.             switch (var.Flags & XslFlags.TypeFilter) {
  352.                 case XslFlags.String:
  353.                     return T.StringX;
  354.                     ;
  355.                     break;
  356.                 case XslFlags.Number:
  357.                     return T.DoubleX;
  358.                 case XslFlags.Boolean:
  359.                     return T.BooleanX;
  360.                 case XslFlags.Node:
  361.                     return T.NodeNotRtf;
  362.                 case XslFlags.Nodeset:
  363.                     return T.NodeNotRtfS;
  364.                 case XslFlags.Rtf:
  365.                     return T.Node;
  366.                 case XslFlags.Node | XslFlags.Rtf:
  367.                     return T.Node;
  368.                 case XslFlags.Node | XslFlags.Nodeset:
  369.                     return T.NodeNotRtfS;
  370.                 case XslFlags.Nodeset | XslFlags.Rtf:
  371.                     return T.NodeS;
  372.                 case XslFlags.Node | XslFlags.Nodeset | XslFlags.Rtf:
  373.                     return T.NodeS;
  374.                 default:
  375.                     return T.ItemS;
  376.             }
  377.         }
  378.        
  379.         // In debugger we need to pass to each (almost) template $namespace parameter with list of namespaces that
  380.         // are defined on stylesheet and this template. In most cases this will be only xmlns:xsl="..."
  381.         // To prevent creating these list with each call-template/apply-template we create one global variable for each unique set of namespaces
  382.         // This function looks through list of existent global variables for suitable ns list and add one if none was found.
  383.         private QilIterator GetNsVar(QilList nsList)
  384.         {
  385.             Debug.Assert(IsDebug, "This is debug only logic");
  386.             // All global vars at this point are nsList like one we are looking now.
  387.             foreach (QilIterator var in this.nsVars) {
  388.                 Debug.Assert(var.XmlType.IsSubtypeOf(T.NamespaceS));
  389.                 Debug.Assert(var.Binding is QilList);
  390.                 QilList varList = (QilList)var.Binding;
  391.                 if (varList.Count != nsList.Count) {
  392.                     continue;
  393.                 }
  394.                 bool found = true;
  395.                 for (int i = 0; i < nsList.Count; i++) {
  396.                     Debug.Assert(nsList[i].NodeType == QilNodeType.NamespaceDecl);
  397.                     Debug.Assert(varList[i].NodeType == QilNodeType.NamespaceDecl);
  398.                     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) {
  399.                         found = false;
  400.                         break;
  401.                     }
  402.                 }
  403.                 if (found) {
  404.                     return var;
  405.                     // Found!
  406.                 }
  407.             }
  408.             QilIterator newVar = f.Let(nsList);
  409.             newVar.DebugName = f.QName("ns" + this.nsVars.Count, XmlReservedNs.NsXslDebug).ToString();
  410.             this.gloVars.Add(newVar);
  411.             this.nsVars.Add(newVar);
  412.             return newVar;
  413.         }
  414.        
  415.         private void PrecompileProtoTemplatesHeaders()
  416.         {
  417.             // All global variables should be in scoupe here.
  418.             List<VarPar> paramWithCalls = null;
  419.             Dictionary<VarPar, Template> paramToTemplate = null;
  420.             Dictionary<VarPar, QilFunction> paramToFunction = null;
  421.            
  422.             foreach (ProtoTemplate tmpl in compiler.AllTemplates) {
  423.                 Debug.Assert(tmpl != null && tmpl.Function == null);
  424.                 Debug.Assert(tmpl.NodeType == XslNodeType.AttributeSet || tmpl.NodeType == XslNodeType.Template);
  425.                 QilList args = f.FormalParameterList();
  426.                 XslFlags flags = !IsDebug ? tmpl.Flags : XslFlags.FullFocus;
  427.                
  428.                 QilList nsList = EnterScope(tmpl);
  429.                 if ((flags & XslFlags.Current) != 0) {
  430.                     args.Add(CreateXslParam(CloneName(nameCurrent), T.NodeNotRtf));
  431.                 }
  432.                 if ((flags & XslFlags.Position) != 0) {
  433.                     args.Add(CreateXslParam(CloneName(namePosition), T.DoubleX));
  434.                 }
  435.                 if ((flags & XslFlags.Last) != 0) {
  436.                     args.Add(CreateXslParam(CloneName(nameLast), T.DoubleX));
  437.                 }
  438.                 if (IsDebug && nsList != null) {
  439.                     // AttributeSet doesn't need this logic because: 1) it doesn't have args; 2) we merge them.
  440.                     // SimplifiedStylesheet has nsList == null as well.
  441.                     QilParameter ns = CreateXslParam(CloneName(nameNamespaces), T.NamespaceS);
  442.                     ns.DefaultValue = GetNsVar(nsList);
  443.                     args.Add(ns);
  444.                 }
  445.                
  446.                 Template template = tmpl as Template;
  447.                 if (template != null) {
  448.                     Debug.Assert(tmpl.NodeType == XslNodeType.Template);
  449.                    
  450.                     CheckSingletonFocus();
  451.                     funcFocus.StartFocus(args, flags);
  452.                     for (int i = 0; i < tmpl.Content.Count; i++) {
  453.                         XslNode node = tmpl.Content[i];
  454.                         if (node.NodeType == XslNodeType.Text) {
  455.                             // NOTE: We should take care of a bizarre case when xsl:param comes after TextCtor:
  456.                             // <xsl:template match="/" xml:space="preserve"> <xsl:param name="par"/>
  457.                             continue;
  458.                         }
  459.                         if (node.NodeType == XslNodeType.Param) {
  460.                             VarPar xslPar = (VarPar)node;
  461.                             EnterScope(xslPar);
  462.                             if (scope.IsLocalVariable(xslPar.Name.LocalName, xslPar.Name.NamespaceUri)) {
  463.                                     /*[XT0580]*/                                ReportError(Res.Xslt_DupLocalVariable, xslPar.Name.QualifiedName);
  464.                             }
  465.                             QilParameter param = CreateXslParam(xslPar.Name, ChooseBestType(xslPar));
  466.                             if (IsDebug) {
  467.                                 param.Annotation = xslPar;
  468.                                 // Actual compilation will happen in CompileProtoTemplate()
  469.                             }
  470.                             else {
  471.                                 if ((xslPar.DefValueFlags & XslFlags.HasCalls) == 0) {
  472.                                     param.DefaultValue = CompileVarParValue(xslPar);
  473.                                 }
  474.                                 else {
  475.                                     // We can't compile param default value here because it contains xsl:call-template and
  476.                                     // we will not be able to compile any calls befor we finish with all headers
  477.                                     // So we compile this default value as a call to helper function. Now we create header for this function
  478.                                     // and preserve this param in paramWithCall list. Later in this function we finaly compile all preserved
  479.                                     // parameters and set resulted default values as helper function definition.
  480.                                     QilList paramFormal = f.FormalParameterList();
  481.                                     QilList paramActual = f.ActualParameterList();
  482.                                     for (int j = 0; j < args.Count; j++) {
  483.                                         QilParameter formal = f.Parameter(args[j].XmlType);
  484.                                         {
  485.                                             formal.DebugName = ((QilParameter)args[j]).DebugName;
  486.                                             formal.Name = CloneName(((QilParameter)args[j]).Name);
  487.                                             SetLineInfo(formal, args[j].SourceLine);
  488.                                         }
  489.                                         paramFormal.Add(formal);
  490.                                         paramActual.Add(args[j]);
  491.                                     }
  492.                                     // Param doesn't know what implicit args it needs, so we pass all implicit args that was passed to its template.
  493.                                     // let's reflect this fact in parans FocusFlags:
  494.                                     xslPar.Flags |= (template.Flags & XslFlags.FocusFilter);
  495.                                     QilFunction paramFunc = f.Function(paramFormal, (xslPar.DefValueFlags & XslFlags.SideEffects) == 0 ? f.False() : f.True(), ChooseBestType(xslPar));
  496.                                     paramFunc.SourceLine = SourceLineInfo.NoSource;
  497.                                     paramFunc.DebugName = "<xsl:param name=\"" + xslPar.Name.QualifiedName + "\">";
  498.                                     param.DefaultValue = f.Invoke(paramFunc, paramActual);
  499.                                     // store VarPar here to compile it on next pass:
  500.                                     if (paramWithCalls == null) {
  501.                                         paramWithCalls = new List<VarPar>();
  502.                                         paramToTemplate = new Dictionary<VarPar, Template>();
  503.                                         paramToFunction = new Dictionary<VarPar, QilFunction>();
  504.                                     }
  505.                                     paramWithCalls.Add(xslPar);
  506.                                     paramToTemplate.Add(xslPar, template);
  507.                                     paramToFunction.Add(xslPar, paramFunc);
  508.                                 }
  509.                             }
  510.                             SetLineInfo(param, xslPar.SourceLine);
  511.                             ExitScope();
  512.                             scope.AddVariable(xslPar.Name, param);
  513.                             args.Add(param);
  514.                         }
  515.                         else {
  516.                             break;
  517.                         }
  518.                     }
  519.                     funcFocus.StopFocus();
  520.                 }
  521.                 ExitScope();
  522.                
  523.                 tmpl.Function = f.Function(args, (tmpl.Flags & XslFlags.SideEffects) == 0 ? f.False() : f.True(), tmpl is AttributeSet ? T.AttributeS : T.NodeNotRtfS);
  524.                 tmpl.Function.DebugName = tmpl.GetDebugName();
  525.                 Debug.Assert((template != null) == (tmpl.SourceLine != null), "Templates must have line information, and attribute sets must not");
  526.                 SetLineInfo(tmpl.Function, tmpl.SourceLine ?? SourceLineInfo.NoSource);
  527.                 this.functions.Add(tmpl.Function);
  528.             }
  529.             // foreach (ProtoTemplate tmpl in compiler.AllTemplates)
  530.             // Finish compiling postponed parameters (those having calls in their default values)
  531.             if (paramWithCalls != null) {
  532.                 Debug.Assert(!IsDebug, "In debug mode we don't generate parumWithCalls functions. Otherwise focus flags should be adjusted");
  533.                 foreach (VarPar par in paramWithCalls) {
  534.                     Template tmpl = paramToTemplate[par];
  535.                     QilFunction func = paramToFunction[par];
  536.                     CheckSingletonFocus();
  537.                     funcFocus.StartFocus(func.Arguments, par.Flags);
  538.                     EnterScope(tmpl);
  539.                     EnterScope(par);
  540.                     foreach (QilParameter arg in func.Arguments) {
  541.                         scope.AddVariable(arg.Name, arg);
  542.                     }
  543.                     func.Definition = CompileVarParValue(par);
  544.                     SetLineInfo(func.Definition, par.SourceLine);
  545.                     ExitScope();
  546.                     ExitScope();
  547.                     funcFocus.StopFocus();
  548.                     this.functions.Add(func);
  549.                 }
  550.             }
  551.         }
  552.        
  553.         private QilParameter CreateXslParam(QilName name, XmlQueryType xt)
  554.         {
  555.             QilParameter arg = f.Parameter(xt);
  556.             arg.DebugName = name.ToString();
  557.             arg.Name = name;
  558.             return arg;
  559.         }
  560.        
  561.         private void CompileProtoTemplate(ProtoTemplate tmpl)
  562.         {
  563.             Debug.Assert(tmpl != null && tmpl.Function != null && tmpl.Function.Definition.NodeType == QilNodeType.Unknown);
  564.            
  565.             EnterScope(tmpl);
  566.            
  567.             CheckSingletonFocus();
  568.             funcFocus.StartFocus(tmpl.Function.Arguments, !IsDebug ? tmpl.Flags : XslFlags.FullFocus);
  569.             foreach (QilParameter arg in tmpl.Function.Arguments) {
  570.                 if (arg.Name.NamespaceUri != XmlReservedNs.NsXslDebug) {
  571.                     Debug.Assert(tmpl is Template, "Only templates can have explicit arguments");
  572.                     if (IsDebug) {
  573.                         Debug.Assert(arg.DefaultValue == null, "Argument must not be compiled yet");
  574.                         VarPar xslParam = (VarPar)arg.Annotation;
  575.                         QilList nsListParam = EnterScope(xslParam);
  576.                         arg.DefaultValue = CompileVarParValue(xslParam);
  577.                         ExitScope();
  578.                         arg.DefaultValue = SetDebugNs(arg.DefaultValue, nsListParam);
  579.                     }
  580.                     else {
  581.                         // in !IsDebug we compile argument default value in PrecompileProtoTemplatesHeaders()
  582.                     }
  583.                     scope.AddVariable(arg.Name, arg);
  584.                 }
  585.             }
  586.             tmpl.Function.Definition = CompileInstructions(tmpl.Content);
  587.             // tmpl.Function.Definition = AddCurrentPositionLast(tmpl.Function.Definition); We don't mask Cur,Pos,Last parameters with Cur,Pos,Last wariables any more
  588.             // tmpl.Function.Definition = SetDebugNs(tmpl.Function.Definition, nsList); We add it as parameter now.
  589.             funcFocus.StopFocus();
  590.            
  591.             ExitScope();
  592.         }
  593.        
  594.         private QilList InstructionList()
  595.         {
  596.             return f.BaseFactory.Sequence();
  597.         }
  598.        
  599.         private QilNode CompileInstructions(IList<XslNode> instructions)
  600.         {
  601.             return CompileInstructions(instructions, 0, InstructionList());
  602.         }
  603.        
  604.         private QilNode CompileInstructions(IList<XslNode> instructions, int from)
  605.         {
  606.             return CompileInstructions(instructions, from, InstructionList());
  607.         }
  608.        
  609.         private QilNode CompileInstructions(IList<XslNode> instructions, QilList content)
  610.         {
  611.             return CompileInstructions(instructions, 0, content);
  612.         }
  613.        
  614.         private QilNode CompileInstructions(IList<XslNode> instructions, int from, QilList content)
  615.         {
  616.             Debug.Assert(instructions != null);
  617.             for (int i = from; i < instructions.Count; i++) {
  618.                 XslNode node = instructions[i];
  619.                 XslNodeType nodeType = node.NodeType;
  620.                 if (nodeType == XslNodeType.Param) {
  621.                     continue;
  622.                     // already compiled by CompileProtoTemplate()
  623.                 }
  624.                 QilList nsList = EnterScope(node);
  625.                 QilNode result;
  626.                
  627.                 switch (nodeType) {
  628.                     case XslNodeType.ApplyImports:
  629.                         result = CompileApplyImports(node);
  630.                         break;
  631.                     case XslNodeType.ApplyTemplates:
  632.                         result = CompileApplyTemplates((XslNodeEx)node);
  633.                         break;
  634.                     case XslNodeType.Attribute:
  635.                         result = CompileAttribute((NodeCtor)node);
  636.                         break;
  637.                     case XslNodeType.CallTemplate:
  638.                         result = CompileCallTemplate((XslNodeEx)node);
  639.                         break;
  640.                     case XslNodeType.Choose:
  641.                         result = CompileChoose(node);
  642.                         break;
  643.                     case XslNodeType.Comment:
  644.                         result = CompileComment(node);
  645.                         break;
  646.                     case XslNodeType.Copy:
  647.                         result = CompileCopy(node);
  648.                         break;
  649.                     case XslNodeType.CopyOf:
  650.                         result = CompileCopyOf(node);
  651.                         break;
  652.                     case XslNodeType.Element:
  653.                         result = CompileElement((NodeCtor)node);
  654.                         break;
  655.                     case XslNodeType.Error:
  656.                         result = CompileError(node);
  657.                         break;
  658.                     case XslNodeType.ForEach:
  659.                         result = CompileForEach((XslNodeEx)node);
  660.                         break;
  661.                     case XslNodeType.If:
  662.                         result = CompileIf(node);
  663.                         break;
  664.                     case XslNodeType.List:
  665.                         result = CompileList(node);
  666.                         break;
  667.                     case XslNodeType.LiteralAttribute:
  668.                         result = CompileLiteralAttribute(node);
  669.                         break;
  670.                     case XslNodeType.LiteralElement:
  671.                         result = CompileLiteralElement(node);
  672.                         break;
  673.                     case XslNodeType.Message:
  674.                         result = CompileMessage(node);
  675.                         break;
  676.                     case XslNodeType.Nop:
  677.                         result = CompileNop(node);
  678.                         break;
  679.                     case XslNodeType.Number:
  680.                         result = CompileNumber((Number)node);
  681.                         break;
  682.                     case XslNodeType.PI:
  683.                         // case XslNodeType.Otherwise: wrapped by Choose
  684.                         // case XslNodeType.Param: already compiled by CompileProtoTemplate()
  685.                         result = CompilePI(node);
  686.                         break;
  687.                     case XslNodeType.Text:
  688.                         // case XslNodeType.Sort: wrapped by ForEach or ApplyTemplates, see CompileSorts()
  689.                         // case XslNodeType.Template: global level element
  690.                         result = CompileText((Text)node);
  691.                         break;
  692.                     case XslNodeType.UseAttributeSet:
  693.                         result = CompileUseAttributeSet(node);
  694.                         break;
  695.                     case XslNodeType.ValueOf:
  696.                         result = CompileValueOf(node);
  697.                         break;
  698.                     case XslNodeType.ValueOfDoe:
  699.                         result = CompileValueOfDoe(node);
  700.                         break;
  701.                     case XslNodeType.Variable:
  702.                         result = CompileVariable(node);
  703.                         break;
  704.                     default:
  705.                         // case XslNodeType.WithParam: wrapped by CallTemplate or ApplyTemplates, see CompileWithParam()
  706.                         Debug.Fail("Unexpected type of AST node: " + nodeType.ToString());
  707.                         result = null;
  708.                         break;
  709.                 }
  710.                
  711.                 ExitScope();
  712.                 Debug.Assert(result != null, "Result of compilation should not be null");
  713.                 if (result.NodeType == QilNodeType.Sequence && result.Count == 0) {
  714.                     continue;
  715.                 }
  716.                
  717.                 // Do not create sequence points for literal attributes and use-attribute-sets
  718.                 if (nodeType != XslNodeType.LiteralAttribute && nodeType != XslNodeType.UseAttributeSet) {
  719.                     SetLineInfoCheck(result, node.SourceLine);
  720.                 }
  721.                
  722.                 result = SetDebugNs(result, nsList);
  723.                 if (nodeType == XslNodeType.Variable) {
  724.                     QilIterator var = f.Let(result);
  725.                     var.DebugName = node.Name.ToString();
  726.                     scope.AddVariable(node.Name, var);
  727.                     // Process all remaining instructions in the recursive call
  728.                     result = f.Loop(var, CompileInstructions(instructions, i + 1));
  729.                     i = instructions.Count;
  730.                 }
  731.                
  732.                 content.Add(result);
  733.             }
  734.             if (!IsDebug && content.Count == 1) {
  735.                 return content[0];
  736.             }
  737.             return content;
  738.         }
  739.        
  740.         private QilNode CompileList(XslNode node)
  741.         {
  742.             return CompileInstructions(node.Content);
  743.         }
  744.        
  745.         private QilNode CompileNop(XslNode node)
  746.         {
  747.             return f.Nop(f.Sequence());
  748.         }
  749.        
  750.         private void AddNsDecl(QilList content, string prefix, string nsUri)
  751.         {
  752.             if (this.outputScope.LookupNamespace(prefix) == nsUri) {
  753.                 return;
  754.                 // This prefix is already bound to required namespace. Nothing to do.
  755.             }
  756.             this.outputScope.AddNamespace(prefix, nsUri);
  757.             content.Add(f.NamespaceDecl(f.String(prefix), f.String(nsUri)));
  758.         }
  759.        
  760.         private QilNode CompileLiteralElement(XslNode node)
  761.         {
  762.             // IlGen requires that namespace declarations do not conflict with the namespace used by the element
  763.             // constructor, see XmlILNamespaceAnalyzer.CheckNamespaceInScope() and SQLBUDT 389481, 389482. First
  764.             // we try to replace all prefixes bound to aliases by result-prefixes of the corresponding
  765.             // xsl:namespace-alias instructions. If there is at least one conflict, we leave all prefixes
  766.             // untouched, changing only namespace URIs.
  767.             bool changePrefixes = true;
  768.             Start:
  769.            
  770.             prefixesInUse.Clear();
  771.            
  772.             QilName qname = node.Name;
  773.             string prefix = qname.Prefix;
  774.             string nsUri = qname.NamespaceUri;
  775.            
  776.             compiler.ApplyNsAliases(ref prefix, ref nsUri);
  777.             if (changePrefixes) {
  778.                 prefixesInUse.Add(prefix, nsUri);
  779.             }
  780.             else {
  781.                 prefix = qname.Prefix;
  782.             }
  783.            
  784.             outputScope.PushScope();
  785.            
  786.             // Declare all namespaces that should be declared
  787.             // <spec>http://www.w3.org/TR/xslt.html#literal-result-element</spec>
  788.             QilList nsList = InstructionList();
  789.             foreach (ScopeRecord rec in this.scope) {
  790.                 string recPrefix = rec.ncName;
  791.                 string recNsUri = rec.nsUri;
  792.                 if (recNsUri != XmlReservedNs.NsXslt && !scope.IsExNamespace(recNsUri)) {
  793.                     compiler.ApplyNsAliases(ref recPrefix, ref recNsUri);
  794.                     if (changePrefixes) {
  795.                         if (prefixesInUse.Contains(recPrefix)) {
  796.                             if ((string)prefixesInUse[recPrefix] != recNsUri) {
  797.                                 // Found a prefix conflict. Start again from the beginning leaving all prefixes untouched.
  798.                                 outputScope.PopScope();
  799.                                 changePrefixes = false;
  800.                                 goto Start;
  801.                             }
  802.                         }
  803.                         else {
  804.                             prefixesInUse.Add(recPrefix, recNsUri);
  805.                         }
  806.                     }
  807.                     else {
  808.                         recPrefix = rec.ncName;
  809.                     }
  810.                     AddNsDecl(nsList, recPrefix, recNsUri);
  811.                 }
  812.             }
  813.            
  814.             QilNode content = CompileInstructions(node.Content, nsList);
  815.             outputScope.PopScope();
  816.            
  817.             qname.Prefix = prefix;
  818.             qname.NamespaceUri = nsUri;
  819.             return f.ElementCtor(qname, content);
  820.         }
  821.        
  822.         private QilNode CompileElement(NodeCtor node)
  823.         {
  824.             QilNode qilNs = CompileStringAvt(node.NsAvt);
  825.             QilNode qilName = CompileStringAvt(node.NameAvt);
  826.             QilNode qname;
  827.            
  828.             if (qilName.NodeType == QilNodeType.LiteralString && (qilNs == null || qilNs.NodeType == QilNodeType.LiteralString)) {
  829.                 string name = (string)(QilLiteral)qilName;
  830.                 string prefix;
  831.                 string local;
  832.                 string nsUri;
  833.                
  834.                 bool isValid = compiler.ParseQName(name, out prefix, out local, (IErrorHelper)this);
  835.                
  836.                 if (qilNs == null) {
  837.                         /*ignoreDefaultNs:*/                    nsUri = isValid ? ResolvePrefix(false, prefix) : compiler.CreatePhantomNamespace();
  838.                 }
  839.                 else {
  840.                     nsUri = (string)(QilLiteral)qilNs;
  841.                 }
  842.                 qname = f.QName(local, nsUri, prefix);
  843.             }
  844.             else {
  845.                 // Process AVT
  846.                 if (qilNs != null) {
  847.                     qname = f.StrParseQName(qilName, qilNs);
  848.                 }
  849.                 else {
  850.                         /*ignoreDefaultNs:*/                    qname = ResolveQNameDynamic(false, qilName);
  851.                 }
  852.             }
  853.            
  854.             outputScope.PushScope();
  855.             this.outputScope.InvalidateAllPrefixes();
  856.             QilNode content = CompileInstructions(node.Content);
  857.             outputScope.PopScope();
  858.            
  859.             return f.ElementCtor(qname, content);
  860.         }
  861.        
  862.         private QilNode CompileLiteralAttribute(XslNode node)
  863.         {
  864.             QilName qname = node.Name;
  865.             string prefix = qname.Prefix;
  866.             string nsUri = qname.NamespaceUri;
  867.             // The default namespace do not apply directly to attributes
  868.             if (prefix.Length != 0) {
  869.                 compiler.ApplyNsAliases(ref prefix, ref nsUri);
  870.             }
  871.             qname.Prefix = prefix;
  872.             qname.NamespaceUri = nsUri;
  873.             return f.AttributeCtor(qname, CompileTextAvt(node.Select));
  874.         }
  875.        
  876.         private QilNode CompileAttribute(NodeCtor node)
  877.         {
  878.             QilNode qilNs = CompileStringAvt(node.NsAvt);
  879.             QilNode qilName = CompileStringAvt(node.NameAvt);
  880.             QilNode qname;
  881.             bool explicitNamespace = false;
  882.            
  883.             if (qilName.NodeType == QilNodeType.LiteralString && (qilNs == null || qilNs.NodeType == QilNodeType.LiteralString)) {
  884.                 string name = (string)(QilLiteral)qilName;
  885.                 string prefix;
  886.                 string local;
  887.                 string nsUri;
  888.                
  889.                 bool isValid = compiler.ParseQName(name, out prefix, out local, (IErrorHelper)this);
  890.                
  891.                 if (qilNs == null) {
  892.                         /*ignoreDefaultNs:*/                    nsUri = isValid ? ResolvePrefix(true, prefix) : compiler.CreatePhantomNamespace();
  893.                 }
  894.                 else {
  895.                     nsUri = (string)(QilLiteral)qilNs;
  896.                     // if both name and ns are non AVT and this ns is already bind to the same prefix we can avoid reseting ns management
  897.                     explicitNamespace = true;
  898.                 }
  899.                 // Check the case <xsl:attribute name="foo:xmlns" namespace=""/>
  900.                 if (name == "xmlns" || local == "xmlns" && nsUri.Length == 0) {
  901.                         /*[XT_031]*/                    ReportError(Res.Xslt_XmlnsAttr, "name", name);
  902.                 }
  903.                 qname = f.QName(local, nsUri, prefix);
  904.             }
  905.             else {
  906.                 // Process AVT
  907.                 if (qilNs != null) {
  908.                     qname = f.StrParseQName(qilName, qilNs);
  909.                 }
  910.                 else {
  911.                         /*ignoreDefaultNs:*/                    qname = ResolveQNameDynamic(true, qilName);
  912.                 }
  913.             }
  914.             if (explicitNamespace) {
  915.                 // Optimization: attribute cannot change the default namespace
  916.                 this.outputScope.InvalidateNonDefaultPrefixes();
  917.             }
  918.             return f.AttributeCtor(qname, CompileInstructions(node.Content));
  919.         }
  920.        
  921.         private readonly StringBuilder unescapedText = new StringBuilder();
  922.        
  923.         private QilNode ExtractText(string source, ref int pos)
  924.         {
  925.             Debug.Assert(pos < source.Length);
  926.             int i;
  927.             int start = pos;
  928.            
  929.             unescapedText.Length = 0;
  930.             for (i = pos; i < source.Length; i++) {
  931.                 char ch = source[i];
  932.                
  933.                 if (ch == '{' || ch == '}') {
  934.                     if (i + 1 < source.Length && source[i + 1] == ch) {
  935.                         // "{{" or "}}"
  936.                         // Double curly brace outside an expression is replaced by a single one
  937.                         i++;
  938.                         unescapedText.Append(source, start, i - start);
  939.                         start = i + 1;
  940.                     }
  941.                     else if (ch == '{') {
  942.                         // single '{'
  943.                         // Expression encountered, returning
  944.                         break;
  945.                     }
  946.                     else {
  947.                         // single '}'
  948.                         // Single '}' outside an expression is an error
  949.                         pos = source.Length;
  950.                         if (xslVersion != XslVersion.ForwardsCompatible) {
  951.                                 /*[XT0370]*/                            ReportError(Res.Xslt_SingleRightBraceInAvt, source);
  952.                             return null;
  953.                         }
  954.                         return f.Error(lastScope.SourceLine, Res.Xslt_SingleRightBraceInAvt, source);
  955.                     }
  956.                 }
  957.             }
  958.            
  959.             Debug.Assert(i == source.Length || source[i] == '{');
  960.             pos = i;
  961.             if (unescapedText.Length == 0) {
  962.                 return i > start ? f.String(source.Substring(start, i - start)) : null;
  963.             }
  964.             else {
  965.                 unescapedText.Append(source, start, i - start);
  966.                 return f.String(unescapedText.ToString());
  967.             }
  968.         }
  969.        
  970.         private QilNode CompileAvt(string source)
  971.         {
  972.             QilList result = f.BaseFactory.Sequence();
  973.             int pos = 0;
  974.             while (pos < source.Length) {
  975.                 QilNode fixedPart = ExtractText(source, ref pos);
  976.                 if (fixedPart != null) {
  977.                     result.Add(fixedPart);
  978.                 }
  979.                 if (pos < source.Length) {
  980.                     // '{' encountered, parse an expression
  981.                     pos++;
  982.                     QilNode exp = CompileXPathExpressionWithinAvt(source, ref pos);
  983.                     result.Add(f.ConvertToString(exp));
  984.                 }
  985.             }
  986.             if (result.Count == 1) {
  987.                 return result[0];
  988.             }
  989.             return result;
  990.         }
  991.        
  992.         static readonly char[] curlyBraces = {'{', '}'};
  993.        
  994.         private QilNode CompileStringAvt(string avt)
  995.         {
  996.             if (avt == null) {
  997.                 return null;
  998.             }
  999.             if (avt.IndexOfAny(curlyBraces) == -1) {
  1000.                 return f.String(avt);
  1001.             }
  1002.             return f.StrConcat(CompileAvt(avt));
  1003.         }
  1004.        
  1005.         private QilNode CompileTextAvt(string avt)
  1006.         {
  1007.             Debug.Assert(avt != null);
  1008.             if (avt.IndexOfAny(curlyBraces) == -1) {
  1009.                 return f.TextCtor(f.String(avt));
  1010.             }
  1011.             QilNode avtParts = CompileAvt(avt);
  1012.             if (avtParts.NodeType == QilNodeType.Sequence) {
  1013.                 QilList result = InstructionList();
  1014.                 foreach (QilNode node in avtParts) {
  1015.                     result.Add(f.TextCtor(node));
  1016.                 }
  1017.                 return result;
  1018.             }
  1019.             else {
  1020.                 return f.TextCtor(avtParts);
  1021.             }
  1022.         }
  1023.        
  1024.         private QilNode CompileText(Text node)
  1025.         {
  1026.             if (node.Hints == SerializationHints.None)
  1027.                 return f.TextCtor(f.String(node.Select));
  1028.            
  1029.             return f.RawTextCtor(f.String(node.Select));
  1030.         }
  1031.        
  1032.         private QilNode CompilePI(XslNode node)
  1033.         {
  1034.             QilNode qilName = CompileStringAvt(node.Select);
  1035.             if (qilName.NodeType == QilNodeType.LiteralString) {
  1036.                 string name = (string)(QilLiteral)qilName;
  1037.                 compiler.ValidatePiName(name, (IErrorHelper)this);
  1038.             }
  1039.             return f.PICtor(qilName, CompileInstructions(node.Content));
  1040.         }
  1041.        
  1042.         private QilNode CompileComment(XslNode node)
  1043.         {
  1044.             return f.CommentCtor(CompileInstructions(node.Content));
  1045.         }
  1046.        
  1047.         private QilNode CompileError(XslNode node)
  1048.         {
  1049.             return f.Error(f.String(node.Select));
  1050.         }
  1051.        
  1052.         private QilNode WrapInSequencePoints(ISourceLineInfo before, QilNode expr, ISourceLineInfo after)
  1053.         {
  1054.             if (IsDebug) {
  1055.                 return f.Sequence(SetLineInfo(f.Nop(f.Sequence()), before), expr, SetLineInfo(f.Nop(f.Sequence()), after));
  1056.             }
  1057.             return expr;
  1058.         }
  1059.        
  1060.         private QilNode CompileForEach(XslNodeEx node)
  1061.         {
  1062.             QilNode result;
  1063.             IList<XslNode> content = node.Content;
  1064.            
  1065.             // Push new loop frame on the stack
  1066.             LoopFocus curLoopSaved = curLoop;
  1067.             QilIterator it = f.For(f.EnsureNodeSet(CompileXPathExpression(node.Select)));
  1068.             curLoop.SetFocus(it);
  1069.            
  1070.             // Compile sort keys and body
  1071.             int varScope = varHelper.StartVariables();
  1072.             curLoop.Sort(CompileSorts(content, ref curLoopSaved));
  1073.             result = CompileInstructions(content);
  1074.             result = WrapInSequencePoints(node.ElemNameLi, result, node.EndTagLi);
  1075.             result = AddCurrentPositionLast(result);
  1076.             result = curLoop.ConstructLoop(result);
  1077.             result = varHelper.FinishVariables(result, varScope);
  1078.            
  1079.             // Pop loop frame
  1080.             curLoop = curLoopSaved;
  1081.             return result;
  1082.         }
  1083.        
  1084.         private QilNode CompileApplyTemplates(XslNodeEx node)
  1085.         {
  1086.             QilNode result;
  1087.             IList<XslNode> content = node.Content;
  1088.            
  1089.             // Calculate select expression
  1090.             int varScope = varHelper.StartVariables();
  1091.            
  1092.             QilIterator select = f.Let(f.EnsureNodeSet(CompileXPathExpression(node.Select)));
  1093.             varHelper.AddVariable(select);
  1094.            
  1095.             // Compile with-param's, they must be calculated outside the loop and
  1096.             // if they are neither constant nor reference we need to cache them in Let's
  1097.             for (int i = 0; i < content.Count; i++) {
  1098.                 VarPar withParam = content[i] as VarPar;
  1099.                 if (withParam != null) {
  1100.                     Debug.Assert(withParam.NodeType == XslNodeType.WithParam);
  1101.                     CompileWithParam(withParam);
  1102.                     QilNode val = withParam.Value;
  1103.                     if (IsDebug || !(val is QilIterator || val is QilLiteral)) {
  1104.                         QilIterator let = f.Let(val);
  1105.                         let.DebugName = f.QName("with-param " + withParam.Name.QualifiedName, XmlReservedNs.NsXslDebug).ToString();
  1106.                         varHelper.AddVariable(let);
  1107.                         withParam.Value = let;
  1108.                     }
  1109.                 }
  1110.             }
  1111.            
  1112.             // Push new loop frame on the stack
  1113.             LoopFocus curLoopSaved = curLoop;
  1114.             QilIterator it = f.For(select);
  1115.             curLoop.SetFocus(it);
  1116.            
  1117.             // Compile sort keys and body
  1118.             curLoop.Sort(CompileSorts(content, ref curLoopSaved));
  1119.            
  1120.             result = GenerateApply((Stylesheet)null, node);
  1121.            
  1122.             result = WrapInSequencePoints(node.ElemNameLi, result, node.EndTagLi);
  1123.             result = AddCurrentPositionLast(result);
  1124.             result = curLoop.ConstructLoop(result);
  1125.            
  1126.             // Pop loop frame
  1127.             curLoop = curLoopSaved;
  1128.            
  1129.             result = varHelper.FinishVariables(result, varScope);
  1130.             return result;
  1131.         }
  1132.        
  1133.         private QilNode CompileApplyImports(XslNode node)
  1134.         {
  1135.             Debug.Assert(node.NodeType == XslNodeType.ApplyImports);
  1136.             Debug.Assert(!curLoop.IsFocusSet, "xsl:apply-imports cannot be inside of xsl:for-each");
  1137.            
  1138.             return GenerateApply((Stylesheet)node.Arg, node);
  1139.         }
  1140.        
  1141.         private QilNode CompileCallTemplate(XslNodeEx node)
  1142.         {
  1143.             VerifyXPathQName(node.Name);
  1144.             int varScope = varHelper.StartVariables();
  1145.            
  1146.             IList<XslNode> content = node.Content;
  1147.             foreach (VarPar withParam in content) {
  1148.                 CompileWithParam(withParam);
  1149.                 // In debug mode precalculate all with-param's
  1150.                 if (IsDebug) {
  1151.                     QilNode val = withParam.Value;
  1152.                     QilIterator let = f.Let(val);
  1153.                     let.DebugName = f.QName("with-param " + withParam.Name.QualifiedName, XmlReservedNs.NsXslDebug).ToString();
  1154.                     varHelper.AddVariable(let);
  1155.                     withParam.Value = let;
  1156.                 }
  1157.             }
  1158.            
  1159.             QilNode result;
  1160.             {
  1161.                 Template tmpl;
  1162.                 if (compiler.NamedTemplates.TryGetValue(node.Name, out tmpl)) {
  1163.                     Debug.Assert(tmpl.Function != null, "All templates should be already compiled");
  1164.                     result = GenerateCall(tmpl.Function, node);
  1165.                 }
  1166.                 else {
  1167.                     if (!compiler.IsPhantomName(node.Name)) {
  1168.                             /*[XT0710]*/                        compiler.ReportError(node.SourceLine, Res.Xslt_InvalidCallTemplate, node.Name.QualifiedName);
  1169.                     }
  1170.                     result = f.Sequence();
  1171.                 }
  1172.             }
  1173.            
  1174.             // Do not create an additional sequence point if there are no parameters
  1175.             if (content.Count > 0) {
  1176.                 result = SetLineInfo(result, node.ElemNameLi);
  1177.             }
  1178.             result = varHelper.FinishVariables(result, varScope);
  1179.             if (IsDebug) {
  1180.                 return f.Nop(result);
  1181.             }
  1182.             return result;
  1183.         }
  1184.        
  1185.         private QilNode CompileUseAttributeSet(XslNode node)
  1186.         {
  1187.             VerifyXPathQName(node.Name);
  1188.             outputScope.InvalidateAllPrefixes();
  1189.            
  1190.             AttributeSet attSet;
  1191.             if (compiler.AttributeSets.TryGetValue(node.Name, out attSet)) {
  1192.                 Debug.Assert(attSet.Function != null, "All templates should be already compiled");
  1193.                 return GenerateCall(attSet.Function, node);
  1194.             }
  1195.             else {
  1196.                 if (!compiler.IsPhantomName(node.Name)) {
  1197.                         /*[XT0710]*/                    compiler.ReportError(node.SourceLine, Res.Xslt_NoAttributeSet, node.Name.QualifiedName);
  1198.                 }
  1199.                 return f.Sequence();
  1200.             }
  1201.         }
  1202.        
  1203.         private const XmlNodeKindFlags InvalidatingNodes = (XmlNodeKindFlags.Attribute | XmlNodeKindFlags.Namespace);
  1204.        
  1205.         private QilNode CompileCopy(XslNode copy)
  1206.         {
  1207.             QilNode node = GetCurrentNode();
  1208.             f.CheckNodeNotRtf(node);
  1209.             if ((node.XmlType.NodeKinds & InvalidatingNodes) != XmlNodeKindFlags.None) {
  1210.                 outputScope.InvalidateAllPrefixes();
  1211.             }
  1212.             if (node.XmlType.NodeKinds == XmlNodeKindFlags.Element) {
  1213.                 // Context node is always an element
  1214.                 // The namespace nodes of the current node are automatically copied
  1215.                 QilList content = InstructionList();
  1216.                 content.Add(f.XPathNamespace(node));
  1217.                 outputScope.PushScope();
  1218.                 outputScope.InvalidateAllPrefixes();
  1219.                 QilNode result = CompileInstructions(copy.Content, content);
  1220.                 outputScope.PopScope();
  1221.                 return f.ElementCtor(f.NameOf(node), result);
  1222.             }
  1223.             else if (node.XmlType.NodeKinds == XmlNodeKindFlags.Document) {
  1224.                 // Context node is always a document
  1225.                 // xsl:copy will not create a document node, but will just use the content template
  1226.                 return CompileInstructions(copy.Content);
  1227.             }
  1228.             else if ((node.XmlType.NodeKinds & (XmlNodeKindFlags.Element | XmlNodeKindFlags.Document)) == XmlNodeKindFlags.None) {
  1229.                 // Context node is neither an element, nor a document
  1230.                 // The content of xsl:copy is not instantiated
  1231.                 return node;
  1232.             }
  1233.             else {
  1234.                 // Static classifying of the context node is not possible
  1235.                 return f.XsltCopy(node, CompileInstructions(copy.Content));
  1236.             }
  1237.         }
  1238.        
  1239.         private QilNode CompileCopyOf(XslNode node)
  1240.         {
  1241.             QilNode selectExpr = CompileXPathExpression(node.Select);
  1242.             if (selectExpr.XmlType.IsNode) {
  1243.                 if ((selectExpr.XmlType.NodeKinds & InvalidatingNodes) != XmlNodeKindFlags.None) {
  1244.                     outputScope.InvalidateAllPrefixes();
  1245.                 }
  1246.                
  1247.                 if (selectExpr.XmlType.IsNotRtf && (selectExpr.XmlType.NodeKinds & XmlNodeKindFlags.Document) == XmlNodeKindFlags.None) {
  1248.                     // Expression returns non-document nodes only
  1249.                     return selectExpr;
  1250.                 }
  1251.                
  1252.                 // May be an Rtf or may return Document nodes, so use XsltCopyOf operator
  1253.                 if (selectExpr.XmlType.IsSingleton) {
  1254.                     return f.XsltCopyOf(selectExpr);
  1255.                 }
  1256.                 else {
  1257.                     QilIterator it;
  1258.                     return f.Loop(it = f.For(selectExpr), f.XsltCopyOf(it));
  1259.                 }
  1260.             }
  1261.             else if (selectExpr.XmlType.IsAtomicValue) {
  1262.                 // Expression returns non-nodes only
  1263.                 // When the result is neither a node-set nor a result tree fragment, the result is converted
  1264.                 // to a string and then inserted into the result tree, as with xsl:value-of.
  1265.                 return f.TextCtor(f.ConvertToString(selectExpr));
  1266.             }
  1267.             else {
  1268.                 // Static classifying is not possible
  1269.                 QilIterator it;
  1270.                 outputScope.InvalidateAllPrefixes();
  1271.                 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))));
  1272.             }
  1273.         }
  1274.        
  1275.         private QilNode CompileValueOf(XslNode valueOf)
  1276.         {
  1277.                 /*select:*/            return f.TextCtor(f.ConvertToString(CompileXPathExpression(valueOf.Select)));
  1278.         }
  1279.        
  1280.         private QilNode CompileValueOfDoe(XslNode valueOf)
  1281.         {
  1282.                 /*select:*/            return f.RawTextCtor(f.ConvertToString(CompileXPathExpression(valueOf.Select)));
  1283.         }
  1284.        
  1285.         private QilNode CompileWhen(XslNode whenNode, QilNode otherwise)
  1286.         {
  1287.                 /*test:*/            return f.Conditional(f.ConvertToBoolean(CompileXPathExpression(whenNode.Select)), CompileInstructions(whenNode.Content), otherwise);
  1288.         }
  1289.        
  1290.         private QilNode CompileIf(XslNode ifNode)
  1291.         {
  1292.             return CompileWhen(ifNode, InstructionList());
  1293.         }
  1294.        
  1295.         private QilNode CompileChoose(XslNode node)
  1296.         {
  1297.             IList<XslNode> cases = node.Content;
  1298.             QilNode result = null;
  1299.            
  1300.             // It's easier to compile xsl:choose from bottom to top
  1301.             for (int i = cases.Count - 1; 0 <= i; i--) {
  1302.                 XslNode when = cases[i];
  1303.                 Debug.Assert(when.NodeType == XslNodeType.If || when.NodeType == XslNodeType.Otherwise);
  1304.                 QilList nsList = EnterScope(when);
  1305.                 if (when.NodeType == XslNodeType.Otherwise) {
  1306.                     Debug.Assert(result == null, "xsl:otherwise must be the last child of xsl:choose");
  1307.                     result = CompileInstructions(when.Content);
  1308.                 }
  1309.                 else {
  1310.                         /*otherwise:*/                    result = CompileWhen(when, result ?? InstructionList());
  1311.                 }
  1312.                 ExitScope();
  1313.                 SetLineInfoCheck(result, when.SourceLine);
  1314.                 result = SetDebugNs(result, nsList);
  1315.             }
  1316.             if (result == null) {
  1317.                 return f.Sequence();
  1318.             }
  1319.             return IsDebug ? f.Sequence(result) : result;
  1320.         }
  1321.        
  1322.         private QilNode CompileMessage(XslNode node)
  1323.         {
  1324.             string baseUri = lastScope.SourceLine.Uri;
  1325.             QilNode content = f.RtfCtor(CompileInstructions(node.Content), f.String(baseUri));
  1326.            
  1327.             //content = f.ConvertToString(content);
  1328.             content = f.InvokeOuterXml(content);
  1329.            
  1330.             // If terminate="no", then create QilNodeType.Warning
  1331.             if (!(bool)node.Arg) {
  1332.                 return f.Warning(content);
  1333.             }
  1334.            
  1335.             // Otherwise create both QilNodeType.Warning and QilNodeType.Error
  1336.             QilIterator i;
  1337.             return f.Loop(i = f.Let(content), f.Sequence(f.Warning(i), f.Error(i)));
  1338.         }
  1339.        
  1340.         private QilNode CompileVariable(XslNode node)
  1341.         {
  1342.             Debug.Assert(node.NodeType == XslNodeType.Variable);
  1343.             if (scope.IsLocalVariable(node.Name.LocalName, node.Name.NamespaceUri)) {
  1344.                     /*[XT_030]*/                ReportError(Res.Xslt_DupLocalVariable, node.Name.QualifiedName);
  1345.             }
  1346.             return CompileVarParValue(node);
  1347.         }
  1348.        
  1349.         private QilNode CompileVarParValue(XslNode node)
  1350.         {
  1351.             Debug.Assert(node.NodeType == XslNodeType.Variable || node.NodeType == XslNodeType.Param || node.NodeType == XslNodeType.WithParam);
  1352.             VerifyXPathQName(node.Name);
  1353.            
  1354.             string baseUri = lastScope.SourceLine.Uri;
  1355.             IList<XslNode> content = node.Content;
  1356.             string select = node.Select;
  1357.             QilNode varValue;
  1358.            
  1359.             if (select != null) {
  1360.                 // In case of incorrect stylesheet, variable or parameter may have both a 'select' attribute and non-empty content
  1361.                 QilList list = InstructionList();
  1362.                 list.Add(CompileXPathExpression(select));
  1363.                 varValue = CompileInstructions(content, list);
  1364.             }
  1365.             else if (content.Count != 0) {
  1366.                 this.outputScope.PushScope();
  1367.                 // Rtf will be instantiated in an unknown namespace context, so we should not assume anything here
  1368.                 this.outputScope.InvalidateAllPrefixes();
  1369.                 varValue = f.RtfCtor(CompileInstructions(content), f.String(baseUri));
  1370.                 this.outputScope.PopScope();
  1371.             }
  1372.             else {
  1373.                 varValue = f.String(string.Empty);
  1374.             }
  1375.             if (IsDebug) {
  1376.                 // In debug mode every variable/param must be of type 'any'
  1377.                 varValue = f.TypeAssert(varValue, T.ItemS);
  1378.             }
  1379.             Debug.Assert(varValue.SourceLine == null);
  1380.             return varValue;
  1381.         }
  1382.        
  1383.         private void CompileWithParam(VarPar withParam)
  1384.         {
  1385.             Debug.Assert(withParam.NodeType == XslNodeType.WithParam);
  1386.             QilList nsList = EnterScope(withParam);
  1387.             QilNode paramValue = CompileVarParValue(withParam);
  1388.             ExitScope();
  1389.             SetLineInfo(paramValue, withParam.SourceLine);
  1390.             paramValue = SetDebugNs(paramValue, nsList);
  1391.             withParam.Value = paramValue;
  1392.         }
  1393.        
  1394.         private QilNode CompileSorts(IList<XslNode> content, ref LoopFocus parentLoop)
  1395.         {
  1396.             QilList keyList = f.BaseFactory.SortKeyList();
  1397.            
  1398.             int i = 0;
  1399.            
  1400.             while (i < content.Count) {
  1401.                 Sort sort = content[i] as Sort;
  1402.                 if (sort != null) {
  1403.                     CompileSort(sort, keyList, ref parentLoop);
  1404.                     content.RemoveAt(i);
  1405.                 }
  1406.                 else {
  1407.                     i++;
  1408.                 }
  1409.             }
  1410.            
  1411.             if (keyList.Count == 0)
  1412.                 return null;
  1413.            
  1414.             return keyList;
  1415.         }
  1416.        
  1417.         private QilNode CompileLangAttribute(string attValue, bool fwdCompat)
  1418.         {
  1419.             QilNode result = CompileStringAvt(attValue);
  1420.            
  1421.             if (result == null) {
  1422.                 // Do nothing
  1423.             }
  1424.             else if (result.NodeType == QilNodeType.LiteralString) {
  1425.                 string lang = (string)(QilLiteral)result;
  1426.                 int lcid = XsltLibrary.LangToLcidInternal(lang, fwdCompat, (IErrorHelper)this);
  1427.                 if (lcid == XsltLibrary.InvariantCultureLcid) {
  1428.                     result = null;
  1429.                 }
  1430.             }
  1431.             else {
  1432.                 // NOTE: We should have the same checks for both compile time and execution time
  1433.                 QilIterator i;
  1434.                 result = f.Loop(i = f.Let(result), f.Conditional(f.Eq(f.InvokeLangToLcid(i, fwdCompat), f.Int32(XsltLibrary.InvariantCultureLcid)), f.String(string.Empty), i));
  1435.             }
  1436.             return result;
  1437.         }
  1438.        
  1439.         private QilNode CompileLangAttributeToLcid(string attValue, bool fwdCompat)
  1440.         {
  1441.             return CompileLangToLcid(CompileStringAvt(attValue), fwdCompat);
  1442.         }
  1443.        
  1444.         private QilNode CompileLangToLcid(QilNode lang, bool fwdCompat)
  1445.         {
  1446.             if (lang == null) {
  1447.                 return f.Double(XsltLibrary.InvariantCultureLcid);
  1448.             }
  1449.             else if (lang.NodeType == QilNodeType.LiteralString) {
  1450.                 return f.Double(XsltLibrary.LangToLcidInternal((string)(QilLiteral)lang, fwdCompat, (IErrorHelper)this));
  1451.             }
  1452.             else {
  1453.                 return f.XsltConvert(f.InvokeLangToLcid(lang, fwdCompat), T.DoubleX);
  1454.             }
  1455.         }
  1456.        
  1457.         private void CompileDataTypeAttribute(string attValue, bool fwdCompat, ref QilNode select, out QilNode select2)
  1458.         {
  1459.             const string DtText = "text";
  1460.             const string DtNumber = "number";
  1461.             QilNode result = CompileStringAvt(attValue);
  1462.             if (result != null) {
  1463.                 if (result.NodeType == QilNodeType.LiteralString) {
  1464.                     string dataType = (string)(QilLiteral)result;
  1465.                     if (dataType == DtNumber) {
  1466.                         select = f.ConvertToNumber(select);
  1467.                         select2 = null;
  1468.                         return;
  1469.                     }
  1470.                     else if (dataType == DtText) {
  1471.                         // fall through to default case
  1472.                     }
  1473.                     else {
  1474.                         if (!fwdCompat) {
  1475.                             // check for qname-but-not-ncname
  1476.                             string prefix;
  1477.                             string local;
  1478.                             string nsUri;
  1479.                             bool isValid = compiler.ParseQName(dataType, out prefix, out local, (IErrorHelper)this);
  1480.                                 /*ignoreDefaultNs:*/                            nsUri = isValid ? ResolvePrefix(true, prefix) : compiler.CreatePhantomNamespace();
  1481.                            
  1482.                             if (nsUri.Length == 0) {
  1483.                                 // this is a ncname; we might report Res.Xslt_InvalidAttrValue,
  1484.                                 // but the following error message is more user friendly
  1485.                             }
  1486.                                 /*[XT_034]*/                            ReportError(Res.Xslt_BistateAttribute, "data-type", DtText, DtNumber);
  1487.                         }
  1488.                         // fall through to default case
  1489.                     }
  1490.                 }
  1491.                 else {
  1492.                     // Precalculate its value outside of for-each loop
  1493.                     QilIterator dt;
  1494.                     QilIterator qname;
  1495.                    
  1496.                         /*ignoreDefaultNs:*/                    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(true, dt)), f.Error(lastScope.SourceLine, Res.Xslt_BistateAttribute, "data-type", DtText, DtNumber)))));
  1497.                    
  1498.                     QilIterator text = f.Let(result);
  1499.                     varHelper.AddVariable(text);
  1500.                    
  1501.                     // Make two sort keys since heterogenous sort keys are not allowed
  1502.                     select2 = select.DeepClone(f.BaseFactory);
  1503.                     select = f.Conditional(text, f.ConvertToString(select), f.String(string.Empty));
  1504.                     select2 = f.Conditional(text, f.Double(0), f.ConvertToNumber(select2));
  1505.                     return;
  1506.                 }
  1507.             }
  1508.            
  1509.             // Default case
  1510.             select = f.ConvertToString(select);
  1511.             select2 = null;
  1512.         }
  1513.        
  1514.         /// <summary>
  1515.         /// Compiles AVT with two possible values
  1516.         /// </summary>
  1517.         /// <param name="attName" >NodeCtor name (used for constructing an error message)</param>
  1518.         /// <param name="attValue" >NodeCtor value</param>
  1519.         /// <param name="value0" >First possible value of attribute</param>
  1520.         /// <param name="value1" >Second possible value of attribute</param>
  1521.         /// <param name="fwdCompat">If true, unrecognized value does not report an error</param>
  1522.         /// <returns>
  1523.         /// If AVT is null (i.e. the attribute is omitted), null is returned. Otherwise, QilExpression
  1524.         /// returning "1" if AVT evaluates to value1, or "0" if AVT evaluates to value0 or any other value.
  1525.         /// If AVT evaluates to neither value0 nor value1 and fwdCompat == false, an error is reported.
  1526.         /// </returns>
  1527.         private QilNode CompileOrderAttribute(string attName, string attValue, string value0, string value1, bool fwdCompat)
  1528.         {
  1529.             QilNode result = CompileStringAvt(attValue);
  1530.             if (result != null) {
  1531.                 if (result.NodeType == QilNodeType.LiteralString) {
  1532.                     string value = (string)(QilLiteral)result;
  1533.                     if (value == value1) {
  1534.                         result = f.String("1");
  1535.                     }
  1536.                     else {
  1537.                         if (value != value0 && !fwdCompat) {
  1538.                                 /*[XT_034]*/                            ReportError(Res.Xslt_BistateAttribute, attName, value0, value1);
  1539.                         }
  1540.                         result = f.String("0");
  1541.                     }
  1542.                 }
  1543.                 else {
  1544.                     QilIterator i;
  1545.                     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))));
  1546.                 }
  1547.                 Debug.Assert(result.XmlType == T.StringX);
  1548.             }
  1549.             return result;
  1550.         }
  1551.        
  1552.         private void CompileSort(Sort sort, QilList keyList, ref LoopFocus parentLoop)
  1553.         {
  1554.             Debug.Assert(sort.NodeType == XslNodeType.Sort);
  1555.             QilNode select;
  1556.             QilNode select2;
  1557.             QilNode lang;
  1558.             QilNode order;
  1559.             QilNode caseOrder;
  1560.             bool fwdCompat;
  1561.            
  1562.             EnterScope(sort);
  1563.             fwdCompat = sort.ForwardsCompatible;
  1564.            
  1565.             select = CompileXPathExpression(sort.Select);
  1566.            
  1567.             if (sort.Lang != null || sort.DataType != null || sort.Order != null || sort.CaseOrder != null) {
  1568.                 // Calculate these attributes in the context of the parent loop
  1569.                 LoopFocus curLoopSaved = curLoop;
  1570.                 curLoop = parentLoop;
  1571.                
  1572.                 lang = CompileLangAttribute(sort.Lang, fwdCompat);
  1573.                
  1574.                 CompileDataTypeAttribute(sort.DataType, fwdCompat, ref select, out select2);
  1575.                
  1576.                     /*attName:  */                    /*attValue: */                    /*value0:  */                    /*value1:  */                    /*fwdCompat:*/                order = CompileOrderAttribute("order", sort.Order, "ascending", "descending", fwdCompat);
  1577.                
  1578.                     /*attName:  */                    /*attValue: */                    /*value0:  */                    /*value1:  */                    /*fwdCompat:*/                caseOrder = CompileOrderAttribute("case-order", sort.CaseOrder, "lower-first", "upper-first", fwdCompat);
  1579.                
  1580.                 // Restore loop context
  1581.                 curLoop = curLoopSaved;
  1582.             }
  1583.             else {
  1584.                 select = f.ConvertToString(select);
  1585.                 select2 = lang = order = caseOrder = null;
  1586.             }
  1587.            
  1588.             strConcat.Reset();
  1589.             strConcat.Append(XmlReservedNs.NsCollationBase);
  1590.             strConcat.Append('/');
  1591.             strConcat.Append(lang);
  1592.            
  1593.             char separator = '?';
  1594.             if (order != null) {
  1595.                 strConcat.Append(separator);
  1596.                 strConcat.Append("descendingOrder=");
  1597.                 strConcat.Append(order);
  1598.                 separator = '&';
  1599.             }
  1600.             if (caseOrder != null) {
  1601.                 strConcat.Append(separator);
  1602.                 strConcat.Append("upperFirst=");
  1603.                 strConcat.Append(caseOrder);
  1604.                 separator = '&';
  1605.             }
  1606.            
  1607.             QilNode collation = strConcat.ToQil();
  1608.            
  1609.             QilSortKey result = f.SortKey(select, collation);
  1610.             // Line information is not copied
  1611.             keyList.Add(result);
  1612.            
  1613.             if (select2 != null) {
  1614.                 result = f.SortKey(select2, collation.DeepClone(f.BaseFactory));
  1615.                 // Line information is not copied
  1616.                 keyList.Add(result);
  1617.             }
  1618.            
  1619.             ExitScope();
  1620.         }
  1621.        
  1622.         private QilNode MatchPattern(QilNode pattern, QilIterator testNode)
  1623.         {
  1624.             QilList list;
  1625.             if (pattern.NodeType == QilNodeType.Error) {
  1626.                 // Invalid pattern
  1627.                 return pattern;
  1628.             }
  1629.             else if (pattern.NodeType == QilNodeType.Sequence) {
  1630.                 list = (QilList)pattern;
  1631.                 Debug.Assert(0 < list.Count, "Pattern should have at least one filter");
  1632.             }
  1633.             else {
  1634.                 list = f.BaseFactory.Sequence();
  1635.                 list.Add(pattern);
  1636.             }
  1637.            
  1638.             QilNode result = f.False();
  1639.             for (int i = list.Count - 1; 0 <= i; i--) {
  1640.                 QilLoop filter = (QilLoop)list[i];
  1641.                 ptrnBuilder.AssertFilter(filter);
  1642.                 result = f.Or(refReplacer.Replace(filter.Body, filter.Variable, testNode), result);
  1643.             }
  1644.             return result;
  1645.         }
  1646.        
  1647.         private QilNode MatchCountPattern(QilNode countPattern, QilIterator testNode)
  1648.         {
  1649.             /*
  1650.                 If the 'count' attribute is not specified, then it defaults to the pattern that matches any node
  1651.                 with the same node kind as the context node and, if the context node has an expanded-QName, with
  1652.                 the same expanded-QName as the context node.
  1653.             */           
  1654. if (countPattern != null) {
  1655.                 return MatchPattern(countPattern, testNode);
  1656.             }
  1657.             else {
  1658.                 QilNode current = GetCurrentNode();
  1659.                 QilNode result;
  1660.                 XmlNodeKindFlags nodeKinds = current.XmlType.NodeKinds;
  1661.                
  1662.                 // If node kind is not known, invoke a runtime function
  1663.                 if ((nodeKinds & (nodeKinds - 1)) != 0) {
  1664.                     return f.InvokeIsSameNodeSort(testNode, current);
  1665.                 }
  1666.                
  1667.                 // Otherwise generate IsType check along with expanded QName check
  1668.                 switch (nodeKinds) {
  1669.                     case XmlNodeKindFlags.Document:
  1670.                         return f.IsType(testNode, T.Document);
  1671.                     case XmlNodeKindFlags.Element:
  1672.                         result = f.IsType(testNode, T.Element);
  1673.                         break;
  1674.                     case XmlNodeKindFlags.Attribute:
  1675.                         result = f.IsType(testNode, T.Attribute);
  1676.                         break;
  1677.                     case XmlNodeKindFlags.Text:
  1678.                         return f.IsType(testNode, T.Text);
  1679.                     case XmlNodeKindFlags.Comment:
  1680.                         return f.IsType(testNode, T.Comment);
  1681.                     case XmlNodeKindFlags.PI:
  1682.                         return f.And(f.IsType(testNode, T.PI), f.Eq(f.LocalNameOf(testNode), f.LocalNameOf(current)));
  1683.                     case XmlNodeKindFlags.Namespace:
  1684.                         return f.And(f.IsType(testNode, T.Namespace), f.Eq(f.LocalNameOf(testNode), f.LocalNameOf(current)));
  1685.                     default:
  1686.                         Debug.Fail("Unexpected NodeKind: " + nodeKinds.ToString());
  1687.                         return f.False();
  1688.                 }
  1689.                
  1690.                 // Elements and attributes have both local name and namespace URI
  1691.                 return f.And(result, f.And(f.Eq(f.LocalNameOf(testNode), f.LocalNameOf(current)), f.Eq(f.NamespaceUriOf(testNode), f.NamespaceUriOf(GetCurrentNode()))));
  1692.             }
  1693.         }
  1694.        
  1695.         private QilNode PlaceMarker(QilNode countPattern, QilNode fromPattern, bool multiple)
  1696.         {
  1697.             /*
  1698.                 Quotation from XSLT 2.0 spec:
  1699.                 * Let $A be the node sequence selected by the expression
  1700.                     ancestor-or-self::node()[matches-count(.)]          (level = "multiple")
  1701.                     ancestor-or-self::node()[matches-count(.)][1]      (level = "single")
  1702.                 * Let $F be the node sequence selected by the expression
  1703.                     ancestor-or-self::node()[matches-from(.)][1]
  1704.                 * Let $AF be the value of
  1705.                     $A intersect ($F/descendant-or-self::node())
  1706.                 * Return the result of the expression
  1707.                     for $af in $AF return 1+count($af/preceding-sibling::node()[matches-count(.)])
  1708.                 NOTE: There are some distinctions between XSLT 1.0 and XSLT 2.0 specs. In our 1.0 implementation we:
  1709.                 1) Assume that the 'matches-from()' function does not match root nodes by default.
  1710.                 2) Instead of '$A intersect ($F/descendant-or-self::node())' (which, by the way,
  1711.                   would filter out attribute and namespace nodes from $A) we calculate
  1712.                     '$A'          if the 'from' attribute is omitted,
  1713.                     '$A[. >> $F]'  if the 'from' attribute is present.
  1714.             */           
  1715.            
  1716. QilNode countPattern2;
  1717.             QilNode countMatches;
  1718.             QilNode fromMatches;
  1719.             QilNode A;
  1720.             QilNode F;
  1721.             QilNode AF;
  1722.             QilIterator i;
  1723.             QilIterator j;
  1724.            
  1725.             countPattern2 = (countPattern != null) ? countPattern.DeepClone(f.BaseFactory) : null;
  1726.             countMatches = f.Filter(i = f.For(f.AncestorOrSelf(GetCurrentNode())), MatchCountPattern(countPattern, i));
  1727.             if (multiple) {
  1728.                 A = f.DocOrderDistinct(countMatches);
  1729.             }
  1730.             else {
  1731.                 A = f.Filter(i = f.For(countMatches), f.Eq(f.PositionOf(i), f.Int32(1)));
  1732.             }
  1733.            
  1734.             if (fromPattern == null) {
  1735.                 AF = A;
  1736.             }
  1737.             else {
  1738.                 fromMatches = f.Filter(i = f.For(f.AncestorOrSelf(GetCurrentNode())), MatchPattern(fromPattern, i));
  1739.                 F = f.Filter(i = f.For(fromMatches), f.Eq(f.PositionOf(i), f.Int32(1)));
  1740.                 AF = f.Loop(i = f.For(F), f.Filter(j = f.For(A), f.Before(i, j)));
  1741.             }
  1742.            
  1743.             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)))));
  1744.         }
  1745.        
  1746.         private QilNode PlaceMarkerAny(QilNode countPattern, QilNode fromPattern)
  1747.         {
  1748.             /*
  1749.                 Quotation from XSLT 2.0 spec:
  1750.                 * If the context node is a document node, return the empty sequence, ()
  1751.                 * Let $A be the node sequence selected by the expression
  1752.                     (preceding::node()|ancestor-or-self::node())[matches-count(.)]
  1753.                 * Let $F be the node sequence selected by the expression
  1754.                     (preceding::node()|ancestor::node())[matches-from(.)][last()]
  1755.                 * Let $AF be the node sequence $A[. is $F or . >> $F].
  1756.                 * If $AF is empty, return the empty sequence, ()
  1757.                 * Otherwise return the value of the expression count($AF)
  1758.                 NOTE: There are some distinctions between XSLT 1.0 and XSLT 2.0 specs. In our 1.0 implementation we:
  1759.                 1) Assume that the 'matches-from()' function does not match root nodes by default.
  1760.                 2) Instead of '$A[. is $F or . >> $F]' we calculate
  1761.                     '$A'          if the 'from' attribute is omitted,
  1762.                     '$A[. >> $F]'  if the 'from' attribute is present.
  1763.             */           
  1764.            
  1765. QilNode range;
  1766.             QilNode fromMatches;
  1767.             QilNode F;
  1768.             QilNode AF;
  1769.             QilIterator i;
  1770.             QilIterator j;
  1771.             QilIterator k;
  1772.            
  1773.             if (fromPattern == null) {
  1774.                 // According to XSLT 2.0 spec, if the 'from' attribute is omitted, matches-from() returns true
  1775.                 // only for the root node. It means $F is a sequence of length one containing the root node,
  1776.                 // and $AF = $A. XSLT 1.0 spec rules lead to the same result $AF = $A, so two specs are compliant here.
  1777.                 range = f.NodeRange(f.Root(GetCurrentNode()), GetCurrentNode());
  1778.                 AF = f.Filter(i = f.For(range), MatchCountPattern(countPattern, i));
  1779.             }
  1780.             else {
  1781.                 fromMatches = f.Filter(i = f.For(f.Preceding(GetCurrentNode())), MatchPattern(fromPattern, i));
  1782.                 F = f.Filter(i = f.For(fromMatches), f.Eq(f.PositionOf(i), f.Int32(1)));
  1783.                 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))));
  1784.             }
  1785.            
  1786.             return f.Loop(k = f.Let(f.Length(AF)), f.Conditional(f.Eq(k, f.Int32(0)), f.Sequence(), k));
  1787.         }
  1788.        
  1789.         // Returns one of XsltLibrary.LetterValue enum values
  1790.         private QilNode CompileLetterValueAttribute(string attValue, bool fwdCompat)
  1791.         {
  1792.             const string Default = "default";
  1793.             const string Alphabetic = "alphabetic";
  1794.             const string Traditional = "traditional";
  1795.            
  1796.             string letterValue;
  1797.             QilNode result = CompileStringAvt(attValue);
  1798.            
  1799.             if (result != null) {
  1800.                 if (result.NodeType == QilNodeType.LiteralString) {
  1801.                     letterValue = (string)(QilLiteral)result;
  1802.                     if (letterValue != Alphabetic && letterValue != Traditional) {
  1803.                         if (!fwdCompat) {
  1804.                                 /*[XT_034]*/                            ReportError(Res.Xslt_BistateAttribute, "letter-value", Alphabetic, Traditional);
  1805.                         }
  1806.                         else {
  1807.                             // Use default value
  1808.                             return f.String(Default);
  1809.                         }
  1810.                     }
  1811.                     return result;
  1812.                 }
  1813.                 else {
  1814.                     QilIterator i = f.Let(result);
  1815.                     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)));
  1816.                 }
  1817.             }
  1818.             return f.String(Default);
  1819.         }
  1820.        
  1821.         private QilNode CompileGroupingSeparatorAttribute(string attValue, bool fwdCompat)
  1822.         {
  1823.             QilNode result = CompileStringAvt(attValue);
  1824.            
  1825.             if (result == null) {
  1826.                 // NOTE: string.Empty value denotes unspecified attribute
  1827.                 result = f.String(string.Empty);
  1828.             }
  1829.             else if (result.NodeType == QilNodeType.LiteralString) {
  1830.                 string value = (string)(QilLiteral)result;
  1831.                 if (value.Length != 1) {
  1832.                     if (!fwdCompat) {
  1833.                             /*[XT_035]*/                        ReportError(Res.Xslt_CharAttribute, "grouping-separator");
  1834.                     }
  1835.                     // See the comment above
  1836.                     result = f.String(string.Empty);
  1837.                 }
  1838.             }
  1839.             else {
  1840.                 QilIterator i = f.Let(result);
  1841.                 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")));
  1842.             }
  1843.             return result;
  1844.         }
  1845.        
  1846.         private QilNode CompileGroupingSizeAttribute(string attValue, bool fwdCompat)
  1847.         {
  1848.             QilNode result = CompileStringAvt(attValue);
  1849.            
  1850.             if (result == null) {
  1851.                 return f.Double(0);
  1852.             }
  1853.             else if (result.NodeType == QilNodeType.LiteralString) {
  1854.                 string groupingSize = (string)(QilLiteral)result;
  1855.                
  1856.                 // NOTE: It is unclear from the spec what we should do with float numbers here.
  1857.                 // Let's apply XPath number and round functions as usual, suppressing any conversion errors.
  1858.                 double dblGroupingSize = XsltFunctions.Round(XPathConvert.StringToDouble(groupingSize));
  1859.                 if (0 <= dblGroupingSize && dblGroupingSize <= int.MaxValue) {
  1860.                     return f.Double(dblGroupingSize);
  1861.                 }
  1862.                 // NaN goes here as well
  1863.                 return f.Double(0);
  1864.             }
  1865.             else {
  1866.                 // NOTE: We should have the same checks for both compile time and execution time
  1867.                 QilIterator i = f.Let(f.ConvertToNumber(result));
  1868.                 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)));
  1869.             }
  1870.         }
  1871.        
  1872.         private QilNode CompileNumber(Number num)
  1873.         {
  1874.             QilNode value;
  1875.            
  1876.             if (num.Value != null) {
  1877.                 value = f.ConvertToNumber(CompileXPathExpression(num.Value));
  1878.             }
  1879.             else {
  1880.                 QilNode countPattern = (num.Count != null) ? CompileNumberPattern(num.Count) : null;
  1881.                 QilNode fromPattern = (num.From != null) ? CompileNumberPattern(num.From) : null;
  1882.                
  1883.                 switch (num.Level) {
  1884.                     case NumberLevel.Single:
  1885.                         value = PlaceMarker(countPattern, fromPattern, false);
  1886.                         break;
  1887.                     case NumberLevel.Multiple:
  1888.                         value = PlaceMarker(countPattern, fromPattern, true);
  1889.                         break;
  1890.                     default:
  1891.                         Debug.Assert(num.Level == NumberLevel.Any);
  1892.                         value = PlaceMarkerAny(countPattern, fromPattern);
  1893.                         break;
  1894.                 }
  1895.             }
  1896.            
  1897.             bool fwdCompat = num.ForwardsCompatible;
  1898.             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)));
  1899.         }
  1900.        
  1901.         // ------------- CompileAndSortMatchPatterns() -------------
  1902.        
  1903.         private void CompileAndSortMatches(Stylesheet sheet)
  1904.         {
  1905.             Debug.Assert(sheet.TemplateMatches.Count == 0);
  1906.            
  1907.             foreach (Template template in sheet.Templates) {
  1908.                 if (template.Match != null) {
  1909.                     EnterScope(template);
  1910.                     QilNode result = CompileMatchPattern(template.Match);
  1911.                     if (result.NodeType == QilNodeType.Sequence) {
  1912.                         QilList filters = (QilList)result;
  1913.                         for (int idx = 0; idx < filters.Count; idx++) {
  1914.                             sheet.AddTemplateMatch(template, (QilLoop)filters[idx]);
  1915.                         }
  1916.                     }
  1917.                     else {
  1918.                         sheet.AddTemplateMatch(template, (QilLoop)result);
  1919.                     }
  1920.                     ExitScope();
  1921.                 }
  1922.             }
  1923.            
  1924.             sheet.SortTemplateMatches();
  1925.            
  1926.             foreach (Stylesheet import in sheet.Imports) {
  1927.                 CompileAndSortMatches(import);
  1928.             }
  1929.         }
  1930.        
  1931.         // ------------- CompileKeys() -------------
  1932.        
  1933.         private void CompileKeys()
  1934.         {
  1935.             CheckSingletonFocus();
  1936.             for (int idx = 0; idx < compiler.Keys.Count; idx++) {
  1937.                 foreach (Key key in compiler.Keys[idx]) {
  1938.                     EnterScope(key);
  1939.                     QilParameter context = f.Parameter(T.NodeNotRtf);
  1940.                     singlFocus.SetFocus(context);
  1941.                     QilIterator values = f.For(f.OptimizeBarrier(CompileKeyMatch(key.Match)));
  1942.                     singlFocus.SetFocus(values);
  1943.                     QilIterator keys = f.For(CompileKeyUse(key.Use));
  1944.                     keys = f.For(f.OptimizeBarrier(f.Loop(keys, f.ConvertToString(keys))));
  1945.                    
  1946.                     QilParameter value = f.Parameter(T.StringX);
  1947.                    
  1948.                     QilFunction func = f.Function(f.FormalParameterList(context, value), f.Filter(values, f.Not(f.IsEmpty(f.Filter(keys, f.Eq(keys, value))))), f.False());
  1949.                    
  1950.                     func.DebugName = key.GetDebugName();
  1951.                     SetLineInfo(func, key.SourceLine);
  1952.                     key.Function = func;
  1953.                     this.functions.Add(func);
  1954.                     ExitScope();
  1955.                 }
  1956.             }
  1957.             singlFocus.SetFocus(null);
  1958.         }
  1959.        
  1960.         // ---------------------- Global variables and parameters -----------------------
  1961.        
  1962.         private void CreateGlobalVarPars()
  1963.         {
  1964.             foreach (VarPar par in compiler.ExternalPars) {
  1965.                 CreateGlobalVarPar(par);
  1966.             }
  1967.             foreach (VarPar var in compiler.GlobalVars) {
  1968.                 CreateGlobalVarPar(var);
  1969.             }
  1970.         }
  1971.        
  1972.         private void CreateGlobalVarPar(VarPar varPar)
  1973.         {
  1974.             Debug.Assert(varPar.NodeType == XslNodeType.Variable || varPar.NodeType == XslNodeType.Param);
  1975.             XmlQueryType xt = ChooseBestType(varPar);
  1976.             QilIterator it;
  1977.             if (varPar.NodeType == XslNodeType.Variable) {
  1978.                 it = f.Let(f.Unknown(xt));
  1979.             }
  1980.             else {
  1981.                 it = f.Parameter(null, varPar.Name, xt);
  1982.             }
  1983.             it.DebugName = varPar.Name.ToString();
  1984.             varPar.Value = it;
  1985.             SetLineInfo(it, varPar.SourceLine);
  1986.             scope.AddVariable(varPar.Name, it);
  1987.         }
  1988.        
  1989.         private void CompileGlobalVariables()
  1990.         {
  1991.             CheckSingletonFocus();
  1992.             singlFocus.SetFocus(SingletonFocusType.InitialDocumentNode);
  1993.            
  1994.             foreach (VarPar par in compiler.ExternalPars) {
  1995.                 extPars.Add(CompileGlobalVarPar(par));
  1996.             }
  1997.             foreach (VarPar var in compiler.GlobalVars) {
  1998.                 gloVars.Add(CompileGlobalVarPar(var));
  1999.             }
  2000.            
  2001.             singlFocus.SetFocus(null);
  2002.         }
  2003.        
  2004.         private QilIterator CompileGlobalVarPar(VarPar varPar)
  2005.         {
  2006.             Debug.Assert(varPar.NodeType == XslNodeType.Variable || varPar.NodeType == XslNodeType.Param);
  2007.             QilIterator it = (QilIterator)varPar.Value;
  2008.            
  2009.             QilList nsList = EnterScope(varPar);
  2010.             QilNode content = CompileVarParValue(varPar);
  2011.             SetLineInfo(content, it.SourceLine);
  2012.             content = AddCurrentPositionLast(content);
  2013.             content = SetDebugNs(content, nsList);
  2014.             it.SourceLine = SourceLineInfo.NoSource;
  2015.             it.Binding = content;
  2016.             ExitScope();
  2017.             return it;
  2018.         }
  2019.        
  2020.         // ------------- CompileXPathExpression() / CompileMatchPattern() / CompileKeyPattern() -----------
  2021.        
  2022.         private void ReportErrorInXPath(XslLoadException e)
  2023.         {
  2024.             XPathCompileException ex = e as XPathCompileException;
  2025.             string errorText = (ex != null) ? ex.FormatDetailedMessage() : e.Message;
  2026.             compiler.ReportError(lastScope.SourceLine, Res.Xml_UserException, errorText);
  2027.         }
  2028.        
  2029.         private QilNode PhantomXPathExpression()
  2030.         {
  2031.             return f.TypeAssert(f.Sequence(), T.ItemS);
  2032.         }
  2033.        
  2034.         private QilNode PhantomKeyMatch()
  2035.         {
  2036.             return f.TypeAssert(f.Sequence(), T.NodeNotRtfS);
  2037.         }
  2038.        
  2039.         // Calls to CompileXPathExpression() can't be nested in the XSLT. So we can reuse the same instance of xpathBuilder.
  2040.         // The only thing we need to do before its use is adjustment of IXPathEnvironment to have correct context tuple.
  2041.         private QilNode CompileXPathExpression(string expr)
  2042.         {
  2043.             XPathScanner scanner;
  2044.             QilNode result;
  2045.            
  2046.                 /*allowVariables:*/                /*allowCurrent:*/                /*allowKey:*/            SetEnvironmentFlags(true, true, true);
  2047.             if (expr == null) {
  2048.                 result = PhantomXPathExpression();
  2049.             }
  2050.             else {
  2051.                 try {
  2052.                     // Note that the constructor may throw an exception, for example, in case of the expression "'"
  2053.                     scanner = new XPathScanner(expr);
  2054.                     result = xpathParser.Parse(scanner, xpathBuilder, LexKind.Eof);
  2055.                 }
  2056.                 catch (XslLoadException e) {
  2057.                     if (xslVersion != XslVersion.ForwardsCompatible) {
  2058.                             /*[XT0300]*/                        ReportErrorInXPath(e);
  2059.                     }
  2060.                     result = f.Error(f.String(e.Message));
  2061.                 }
  2062.             }
  2063.             if (result is QilIterator) {
  2064.                 result = f.Nop(result);
  2065.             }
  2066.             return result;
  2067.         }
  2068.        
  2069.         private QilNode CompileXPathExpressionWithinAvt(string expr, ref int pos)
  2070.         {
  2071.             Debug.Assert(expr != null);
  2072.             XPathScanner scanner;
  2073.             QilNode result;
  2074.             int startPos = pos;
  2075.            
  2076.                 /*allowVariables:*/                /*allowCurrent:*/                /*allowKey:*/            SetEnvironmentFlags(true, true, true);
  2077.             try {
  2078.                 scanner = new XPathScanner(expr, pos);
  2079.                 result = xpathParser.Parse(scanner, xpathBuilder, LexKind.RBrace);
  2080.                 pos = scanner.LexStart + 1;
  2081.             }
  2082.             catch (XslLoadException e) {
  2083.                 if (xslVersion != XslVersion.ForwardsCompatible) {
  2084.                         /*[XT0350][XT0360]*/                    ReportErrorInXPath(e);
  2085.                 }
  2086.                 result = f.Error(f.String(e.Message));
  2087.                 pos = expr.Length;
  2088.             }
  2089.             if (result is QilIterator) {
  2090.                 result = f.Nop(result);
  2091.             }
  2092.             return result;
  2093.         }
  2094.        
  2095.         private QilNode CompileMatchPattern(string pttrn)
  2096.         {
  2097.             Debug.Assert(pttrn != null);
  2098.             XPathScanner scanner;
  2099.             QilNode result;
  2100.            
  2101.                 /*allowVariables:*/                /*allowCurrent:*/                /*allowKey:*/            SetEnvironmentFlags(false, false, true);
  2102.             try {
  2103.                 scanner = new XPathScanner(pttrn);
  2104.                 result = ptrnParser.Parse(scanner, ptrnBuilder);
  2105.             }
  2106.             catch (XslLoadException e) {
  2107.                 if (xslVersion != XslVersion.ForwardsCompatible) {
  2108.                         /*[XT0340]*/                    ReportErrorInXPath(e);
  2109.                 }
  2110.                 result = f.Loop(f.For(ptrnBuilder.FixupNode), f.Error(f.String(e.Message)));
  2111.                 XPathPatternBuilder.SetPriority(result, 0.5);
  2112.             }
  2113.             return result;
  2114.         }
  2115.        
  2116.         private QilNode CompileNumberPattern(string pttrn)
  2117.         {
  2118.             Debug.Assert(pttrn != null);
  2119.             XPathScanner scanner;
  2120.             QilNode result;
  2121.            
  2122.                 /*allowVariables:*/                /*allowCurrent:*/                /*allowKey:*/            SetEnvironmentFlags(true, false, true);
  2123.             try {
  2124.                 scanner = new XPathScanner(pttrn);
  2125.                 result = ptrnParser.Parse(scanner, ptrnBuilder);
  2126.             }
  2127.             catch (XslLoadException e) {
  2128.                 if (xslVersion != XslVersion.ForwardsCompatible) {
  2129.                         /*[XT0340]*/                    ReportErrorInXPath(e);
  2130.                 }
  2131.                 result = f.Error(f.String(e.Message));
  2132.             }
  2133.             return result;
  2134.         }
  2135.        
  2136.         private QilNode CompileKeyMatch(string pttrn)
  2137.         {
  2138.             XPathScanner scanner;
  2139.             QilNode result;
  2140.            
  2141.             if (keyMatchBuilder == null) {
  2142.                 keyMatchBuilder = new KeyMatchBuilder((IXPathEnvironment)this);
  2143.             }
  2144.                 /*allowVariables:*/                /*allowCurrent:*/                /*allowKey:*/            SetEnvironmentFlags(false, false, false);
  2145.             if (pttrn == null) {
  2146.                 result = PhantomKeyMatch();
  2147.             }
  2148.             else {
  2149.                 try {
  2150.                     scanner = new XPathScanner(pttrn);
  2151.                     result = ptrnParser.Parse(scanner, keyMatchBuilder);
  2152.                 }
  2153.                 catch (XslLoadException e) {
  2154.                     if (xslVersion != XslVersion.ForwardsCompatible) {
  2155.                             /*[XT0340]*/                        ReportErrorInXPath(e);
  2156.                     }
  2157.                     result = f.Error(f.String(e.Message));
  2158.                 }
  2159.             }
  2160.             return result;
  2161.         }
  2162.        
  2163.         private QilNode CompileKeyUse(string expr)
  2164.         {
  2165.             XPathScanner scanner;
  2166.             QilNode result;
  2167.            
  2168.                 /*allowVariables:*/                /*allowCurrent:*/                /*allowKey:*/            SetEnvironmentFlags(false, true, false);
  2169.             if (expr == null) {
  2170.                 result = PhantomXPathExpression();
  2171.             }
  2172.             else {
  2173.                 try {
  2174.                     scanner = new XPathScanner(expr);
  2175.                     result = xpathParser.Parse(scanner, xpathBuilder, LexKind.Eof);
  2176.                 }
  2177.                 catch (XslLoadException e) {
  2178.                     if (xslVersion != XslVersion.ForwardsCompatible) {
  2179.                             /*[XT0300]*/                        ReportErrorInXPath(e);
  2180.                     }
  2181.                     result = f.Error(f.String(e.Message));
  2182.                 }
  2183.             }
  2184.             if (result is QilIterator) {
  2185.                 result = f.Nop(result);
  2186.             }
  2187.             return result;
  2188.         }
  2189.        
  2190.         private QilNode ResolveQNameDynamic(bool ignoreDefaultNs, QilNode qilName)
  2191.         {
  2192.             f.CheckString(qilName);
  2193.             QilList nsDecls = f.BaseFactory.Sequence();
  2194.             if (ignoreDefaultNs) {
  2195.                 nsDecls.Add(f.NamespaceDecl(f.String(string.Empty), f.String(string.Empty)));
  2196.             }
  2197.             foreach (ScopeRecord rec in this.scope) {
  2198.                 string recPrefix = rec.ncName;
  2199.                 string recNsUri = rec.nsUri;
  2200.                
  2201.                 if (ignoreDefaultNs && recPrefix.Length == 0) {
  2202.                     // Do not take into account the default namespace
  2203.                 }
  2204.                 else {
  2205.                     nsDecls.Add(f.NamespaceDecl(f.String(recPrefix), f.String(recNsUri)));
  2206.                 }
  2207.             }
  2208.             return f.StrParseQName(qilName, nsDecls);
  2209.         }
  2210.        
  2211.         // ----------------- use-attribute-sets, call-templates, apply-templates, apply-imports ----------------------------- //
  2212.        
  2213.         private QilNode GenerateCall(QilFunction func, XslNode node)
  2214.         {
  2215.             Debug.Assert(node.NodeType == XslNodeType.CallTemplate || node.NodeType == XslNodeType.UseAttributeSet);
  2216.            
  2217.             AddImplicitArgs(node);
  2218.             return invkGen.GenerateInvoke(func, node.Content);
  2219.         }
  2220.        
  2221.         private QilNode GenerateApply(Stylesheet sheet, XslNode node)
  2222.         {
  2223.             Debug.Assert(node.NodeType == XslNodeType.ApplyTemplates || node.NodeType == XslNodeType.ApplyImports);
  2224.            
  2225.             if (compiler.Settings.CheckOnly) {
  2226.                 return f.Sequence();
  2227.             }
  2228.             AddImplicitArgs(node);
  2229.                 /*mode:*/            return InvokeApplyFunction(sheet, node.Name, node.Content);
  2230.         }
  2231.        
  2232.         private void AddImplicitArgs(XslNode node)
  2233.         {
  2234.             Debug.Assert(node.NodeType == XslNodeType.CallTemplate || node.NodeType == XslNodeType.UseAttributeSet || node.NodeType == XslNodeType.ApplyTemplates || node.NodeType == XslNodeType.ApplyImports);
  2235.            
  2236.             XslFlags flags = 0;
  2237.            
  2238.             if (IsDebug) {
  2239.                 flags = XslFlags.FullFocus;
  2240.             }
  2241.             else {
  2242.                 if (node.NodeType == XslNodeType.CallTemplate) {
  2243.                     Template tmpl;
  2244.                     if (compiler.NamedTemplates.TryGetValue(node.Name, out tmpl)) {
  2245.                         flags = tmpl.Flags;
  2246.                     }
  2247.                 }
  2248.                 else if (node.NodeType == XslNodeType.UseAttributeSet) {
  2249.                     AttributeSet attSet;
  2250.                     if (compiler.AttributeSets.TryGetValue(node.Name, out attSet)) {
  2251.                         flags = attSet.Flags;
  2252.                     }
  2253.                 }
  2254.                 else {
  2255.                     if (!compiler.ModeFlags.TryGetValue(node.Name, out flags)) {
  2256.                         flags = 0;
  2257.                     }
  2258.                     // Due to recursive nature of xsl:apply-templates/imports we always need current node
  2259.                     flags |= XslFlags.Current;
  2260.                 }
  2261.             }
  2262.            
  2263.             List<XslNode> implicitArgs = new List<XslNode>();
  2264.             {
  2265.                 if ((flags & XslFlags.Current) != 0) {
  2266.                     implicitArgs.Add(CreateWithParam(nameCurrent, GetCurrentNode()));
  2267.                 }
  2268.                 if ((flags & XslFlags.Position) != 0) {
  2269.                     implicitArgs.Add(CreateWithParam(namePosition, GetCurrentPosition()));
  2270.                 }
  2271.                 if ((flags & XslFlags.Last) != 0) {
  2272.                     implicitArgs.Add(CreateWithParam(nameLast, GetLastPosition()));
  2273.                 }
  2274.             }
  2275.             ;
  2276.            
  2277.             node.InsertContent(implicitArgs);
  2278.         }
  2279.        
  2280.         public static VarPar CreateWithParam(QilName name, QilNode value)
  2281.         {
  2282.             VarPar withParam = AstFactory.WithParam(name);
  2283.             withParam.Value = value;
  2284.             return withParam;
  2285.         }
  2286.        
  2287.         // Fills invokeArgs with values from actualArgs in order given by formalArgs
  2288.         // Returns true if formalArgs maps 1:1 with actual args.
  2289.         // Formaly this is n*n algorithm. We can optimize it by calculationg "signature"
  2290.         // of the function as sum of all hashes of its args names.
  2291.         private bool FillupInvokeArgs(IList<QilNode> formalArgs, IList<XslNode> actualArgs, QilList invokeArgs)
  2292.         {
  2293.             if (actualArgs.Count != formalArgs.Count) {
  2294.                 return false;
  2295.             }
  2296.             invokeArgs.Clear();
  2297.             for (int invArg = 0; invArg < formalArgs.Count; invArg++) {
  2298.                 QilName formalArgName = ((QilParameter)formalArgs[invArg]).Name;
  2299.                 XmlQueryType paramType = formalArgs[invArg].XmlType;
  2300.                 QilNode arg = null;
  2301.                 {
  2302.                     for (int actArg = 0; actArg < actualArgs.Count; actArg++) {
  2303.                         Debug.Assert(actualArgs[actArg].NodeType == XslNodeType.WithParam, "All Sorts was removed in CompileSorts()");
  2304.                         VarPar withParam = (VarPar)actualArgs[actArg];
  2305.                         if (formalArgName.Equals(withParam.Name)) {
  2306.                             QilNode value = withParam.Value;
  2307.                             XmlQueryType valueType = value.XmlType;
  2308.                             if (valueType != paramType) {
  2309.                                 if (valueType.IsNode && paramType.IsNode && valueType.IsSubtypeOf(paramType)) {
  2310.                                     // We can pass it
  2311.                                 }
  2312.                                 else {
  2313.                                     // Formal argument has the same name but a different type
  2314.                                     return false;
  2315.                                 }
  2316.                             }
  2317.                             arg = value;
  2318.                             break;
  2319.                         }
  2320.                     }
  2321.                 }
  2322.                 if (arg == null) {
  2323.                     // Formal argument has not been found among actual arguments
  2324.                     return false;
  2325.                 }
  2326.                 invokeArgs.Add(arg);
  2327.             }
  2328.             // All arguments have been found
  2329.             return true;
  2330.         }
  2331.        
  2332.         private QilNode InvokeApplyFunction(Stylesheet sheet, QilName mode, IList<XslNode> actualArgs)
  2333.         {
  2334.             // Here we create function that has one argument for each with-param in apply-templates
  2335.             // We have actualArgs -- list of xsl:with-param(name, value)
  2336.             // From it we create:
  2337.             // invokeArgs -- values to use with QilInvoke
  2338.             // formalArgs -- list of iterators to use with QilFunction
  2339.             // actualArgs -- modify it to hold iterators (formalArgs) instead of values to ise in invoke generator inside function budy
  2340.            
  2341.             // Special treatment for current/position/last
  2342.             XslFlags flags;
  2343.             if (!compiler.ModeFlags.TryGetValue(mode, out flags)) {
  2344.                 flags = 0;
  2345.             }
  2346.             if (IsDebug) {
  2347.                 flags = XslFlags.FullFocus;
  2348.             }
  2349.            
  2350.             flags |= XslFlags.Current;
  2351.             // Due to recursive nature of Apply(Templates/Imports) we will need current node any way
  2352.             Debug.Assert(actualArgs[0].Name == nameCurrent, "Caller should always pass $current as a first argument to apply-* calls.");
  2353.            
  2354.             QilList invokeArgs = f.ActualParameterList();
  2355.             QilFunction applyFunction = null;
  2356.            
  2357.             // Look at the list of all functions that have been already built. If a suitable one is found, reuse it.
  2358.             Dictionary<QilName, List<QilFunction>> funcTable = (sheet == null ? compiler.ApplyTemplatesFunctions : sheet.ApplyImportsFunctions);
  2359.            
  2360.             List<QilFunction> functionsForMode;
  2361.             if (!funcTable.TryGetValue(mode, out functionsForMode)) {
  2362.                 functionsForMode = funcTable[mode] = new List<QilFunction>();
  2363.             }
  2364.            
  2365.             foreach (QilFunction func in functionsForMode) {
  2366.                 if (FillupInvokeArgs(func.Arguments, actualArgs, invokeArgs))/*ref*/ {
  2367.                     applyFunction = func;
  2368.                     break;
  2369.                 }
  2370.             }
  2371.            
  2372.             // If a suitable function has not been found, create it
  2373.             if (applyFunction == null) {
  2374.                 invokeArgs.Clear();
  2375.                 // We wasn't able to find suitable function. Let's build new:
  2376.                 // 1. Function arguments
  2377.                 QilList formalArgs = f.FormalParameterList();
  2378.                 for (int i = 0; i < actualArgs.Count; i++) {
  2379.                     Debug.Assert(actualArgs[i].NodeType == XslNodeType.WithParam, "All Sorts was removed in CompileSorts()");
  2380.                     VarPar withParam = (VarPar)actualArgs[i];
  2381.                    
  2382.                     // Add actual arg to 'invokeArgs' array. No need to clone it since it must be
  2383.                     // a literal or a reference.
  2384.                     invokeArgs.Add(withParam.Value);
  2385.                    
  2386.                     // Create correspondent formal arg
  2387.                     QilParameter formalArg = f.Parameter(i == 0 ? T.NodeNotRtf : withParam.Value.XmlType);
  2388.                     formalArg.Name = CloneName(withParam.Name);
  2389.                     formalArgs.Add(formalArg);
  2390.                    
  2391.                     // Change actual arg value to formalArg for reuse in calling built-in templates rules
  2392.                     withParam.Value = formalArg;
  2393.                 }
  2394.                
  2395.                 // 2. Function header
  2396.                 applyFunction = f.Function(formalArgs, f.False(), T.NodeNotRtfS);
  2397.                 string attMode = (mode.LocalName.Length == 0) ? string.Empty : " mode=\"" + mode.QualifiedName + '"';
  2398.                 applyFunction.DebugName = (sheet == null ? "<xsl:apply-templates" : "<xsl:apply-imports") + attMode + '>';
  2399.                 functionsForMode.Add(applyFunction);
  2400.                 this.functions.Add(applyFunction);
  2401.                
  2402.                 // 3. Function body
  2403.                 QilIterator current = (QilIterator)formalArgs[0];
  2404.                
  2405.                 // 3.1 Built-in templates
  2406.                     // This will be fixed up later
  2407.                 QilTernary builtinTemplates = f.BaseFactory.Conditional(f.IsType(current, elementOrDocumentType), f.BaseFactory.Nop(f.BaseFactory.Unknown(T.NodeNotRtfS)), f.Conditional(f.IsType(current, textOrAttributeType), f.TextCtor(f.XPathNodeValue(current)), f.Sequence()));
  2408.                
  2409.                 // 3.2 Stylesheet templates
  2410.                     /*applyImports:*/                matcherBuilder.CollectPatterns(sheet ?? compiler.PrincipalStylesheet, mode, sheet != null);
  2411.                     /*otherwise:*/                applyFunction.Definition = matcherBuilder.BuildMatcher(current, actualArgs, builtinTemplates);
  2412.                
  2413.                 // 3.3 Fix up the loop in built-in templates
  2414.                 QilLoop loopOnContent;
  2415.                 {
  2416.                     QilIterator iChild = f.For(f.Content(current));
  2417.                     QilNode filter = f.Filter(iChild, f.IsType(iChild, T.Content));
  2418.                     filter.XmlType = T.ContentS;
  2419.                     // not attribute
  2420.                     LoopFocus curLoopSaved = curLoop;
  2421.                     curLoop.SetFocus(f.For(filter));
  2422.                     if ((flags & XslFlags.Last) != 0) {
  2423.                         // Mark that we need last argument
  2424.                         curLoop.GetLast();
  2425.                     }
  2426.                    
  2427.                     /* Prepare actual arguments */ {
  2428.                         // At XSLT 1.0, if a built-in template rule is invoked with parameters, the parameters are not
  2429.                         // passed on to any templates invoked by the built-in rule. At XSLT 2.0, these parameters are
  2430.                         // passed through the built-in template rule unchanged.
  2431.                         const bool Xslt10Rules = true;
  2432.                         if (Xslt10Rules) {
  2433.                             List<XslNode> newActualArgs = new List<XslNode>(3);
  2434.                             int argNum = 0;
  2435.                             if ((flags & XslFlags.Current) != 0) {
  2436.                                 newActualArgs.Add(actualArgs[argNum++]);
  2437.                             }
  2438.                             if ((flags & XslFlags.Position) != 0) {
  2439.                                 newActualArgs.Add(actualArgs[argNum++]);
  2440.                             }
  2441.                             if ((flags & XslFlags.Last) != 0) {
  2442.                                 newActualArgs.Add(actualArgs[argNum++]);
  2443.                             }
  2444.                             actualArgs = newActualArgs;
  2445.                         }
  2446.                        
  2447.                         // Fix values of current, position, and last
  2448.                         {
  2449.                             int argNum = 0;
  2450.                             if ((flags & XslFlags.Current) != 0) {
  2451.                                 ((VarPar)actualArgs[argNum++]).Value = GetCurrentNode();
  2452.                             }
  2453.                             if ((flags & XslFlags.Position) != 0) {
  2454.                                 ((VarPar)actualArgs[argNum++]).Value = GetCurrentPosition();
  2455.                             }
  2456.                             if ((flags & XslFlags.Last) != 0) {
  2457.                                 ((VarPar)actualArgs[argNum++]).Value = GetLastPosition();
  2458.                             }
  2459.                         }
  2460.                     }
  2461.                         /*sheet:*/                    loopOnContent = curLoop.ConstructLoop(InvokeApplyFunction(null, mode, actualArgs));
  2462.                     curLoop = curLoopSaved;
  2463.                 }
  2464.                
  2465.                 Debug.Assert(builtinTemplates.Center.NodeType == QilNodeType.Nop);
  2466.                 ((QilUnary)builtinTemplates.Center).Child = loopOnContent;
  2467.             }
  2468.             return f.Invoke(applyFunction, invokeArgs);
  2469.         }
  2470.        
  2471.         // -------------------------------- IErrorHelper --------------------------------
  2472.        
  2473.         public void ReportError(string res, params string[] args)
  2474.         {
  2475.             compiler.ReportError(lastScope.SourceLine, res, args);
  2476.         }
  2477.        
  2478.         public void ReportWarning(string res, params string[] args)
  2479.         {
  2480.             compiler.ReportWarning(lastScope.SourceLine, res, args);
  2481.         }
  2482.        
  2483.         // ------------------------------------------------------------------------------
  2484.        
  2485.         [Conditional("DEBUG")]
  2486.         private void VerifyXPathQName(QilName qname)
  2487.         {
  2488.                 /*ignoreDefaultNs:*/            Debug.Assert(compiler.IsPhantomName(qname) || qname.NamespaceUri == ResolvePrefix(true, qname.Prefix), "QilGenerator must resolve the prefix to the same namespace as XsltLoader");
  2489.         }
  2490.        
  2491.         private string ResolvePrefix(bool ignoreDefaultNs, string prefix)
  2492.         {
  2493.             if (ignoreDefaultNs && prefix.Length == 0) {
  2494.                 return string.Empty;
  2495.             }
  2496.             else {
  2497.                 string ns = scope.LookupNamespace(prefix);
  2498.                 if (ns == null) {
  2499.                     if (prefix.Length == 0) {
  2500.                         ns = string.Empty;
  2501.                     }
  2502.                     else {
  2503.                             /*[XT0280]*/                        ReportError(Res.Xslt_InvalidPrefix, prefix);
  2504.                         ns = compiler.CreatePhantomNamespace();
  2505.                     }
  2506.                 }
  2507.                 return ns;
  2508.             }
  2509.         }
  2510.        
  2511.         private void SetLineInfoCheck(QilNode n, ISourceLineInfo lineInfo)
  2512.         {
  2513.             // Prevent xsl:choose override xsl:when, etc.
  2514.             if (n.SourceLine == null) {
  2515.                 SetLineInfo(n, lineInfo);
  2516.             }
  2517.             else {
  2518.                 Debug.Assert(!IsDebug, "Attempt to override SourceLineInfo in debug mode");
  2519.             }
  2520.         }
  2521.        
  2522.         private static QilNode SetLineInfo(QilNode n, ISourceLineInfo lineInfo)
  2523.         {
  2524.             Debug.Assert(n.SourceLine == null);
  2525.             if (lineInfo != null) {
  2526.                 SourceLineInfo.Validate(lineInfo);
  2527.                 if (0 < lineInfo.StartLine && lineInfo.StartLine <= lineInfo.EndLine) {
  2528.                     n.SourceLine = lineInfo;
  2529.                 }
  2530.             }
  2531.             return n;
  2532.         }
  2533.        
  2534.         private QilNode AddDebugVariable(QilName name, QilNode value, QilNode content)
  2535.         {
  2536.             QilIterator var = f.Let(value);
  2537.             var.DebugName = name.ToString();
  2538.             return f.Loop(var, content);
  2539.         }
  2540.        
  2541.         private QilNode SetDebugNs(QilNode n, QilList nsList)
  2542.         {
  2543.             if (n != null && nsList != null) {
  2544.                 QilNode nsVar = GetNsVar(nsList);
  2545.                 Debug.Assert(nsVar.XmlType.IsSubtypeOf(T.NamespaceS));
  2546.                 if (nsVar.XmlType.Cardinality == XmlQueryCardinality.One) {
  2547.                     // We want CLR type to be XmlQuerySequence instead of XPathNavigator
  2548.                     nsVar = f.TypeAssert(nsVar, T.NamespaceS);
  2549.                 }
  2550.                 n = AddDebugVariable(CloneName(nameNamespaces), nsVar, n);
  2551.             }
  2552.             return n;
  2553.         }
  2554.        
  2555.         private QilNode AddCurrentPositionLast(QilNode content)
  2556.         {
  2557.             if (IsDebug) {
  2558.                 content = AddDebugVariable(CloneName(nameLast), GetLastPosition(), content);
  2559.                 content = AddDebugVariable(CloneName(namePosition), GetCurrentPosition(), content);
  2560.                 content = AddDebugVariable(CloneName(nameCurrent), GetCurrentNode(), content);
  2561.             }
  2562.             return content;
  2563.         }
  2564.        
  2565.         private QilName CloneName(QilName name)
  2566.         {
  2567.             return (QilName)name.ShallowClone(f.BaseFactory);
  2568.         }
  2569.        
  2570.         // This helper internal class is used for compiling sort's and with-param's
  2571.         private class VariableHelper
  2572.         {
  2573.             private Stack<QilIterator> vars = new Stack<QilIterator>();
  2574.             private XPathQilFactory f;
  2575.            
  2576.             public VariableHelper(XPathQilFactory f)
  2577.             {
  2578.                 this.f = f;
  2579.             }
  2580.            
  2581.             public int StartVariables()
  2582.             {
  2583.                 return vars.Count;
  2584.             }
  2585.            
  2586.             public void AddVariable(QilIterator let)
  2587.             {
  2588.                 Debug.Assert(let.NodeType == QilNodeType.Let);
  2589.                 vars.Push(let);
  2590.             }
  2591.            
  2592.             public QilNode FinishVariables(QilNode node, int varScope)
  2593.             {
  2594.                 Debug.Assert(0 <= varScope && varScope <= vars.Count);
  2595.                 for (int i = vars.Count - varScope; i-- != 0;) {
  2596.                     node = f.Loop(vars.Pop(), node);
  2597.                 }
  2598.                 return node;
  2599.             }
  2600.            
  2601.             [Conditional("DEBUG")]
  2602.             public void CheckEmpty()
  2603.             {
  2604.                 Debug.Assert(vars.Count == 0, "Accumulated variables left unclaimed");
  2605.             }
  2606.         }
  2607.     }
  2608. }

Developer Fusion