The Labs \ Source Viewer \ SSCLI \ System.Xml.Xsl.Qil \ QilPatternFactory

  1. //------------------------------------------------------------------------------
  2. // <copyright file="QilPatternFactory.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. //------------------------------------------------------------------------------
  15. using System.Collections.Generic;
  16. using System.Diagnostics;
  17. using System.Reflection;
  18. using System.Xml.Schema;
  19. namespace System.Xml.Xsl.Qil
  20. {
  21.    
  22.     /// <summary>
  23.     /// Additional factory methods for constructing common QIL patterns.
  24.     /// </summary>
  25.     /// <remarks>
  26.     /// Some of the methods here are exactly like the ones in QilFactory except
  27.     /// that they perform constant-folding and other normalization. Others are
  28.     /// "macro patterns" that simplify the task of constructing otherwise complex patterns.
  29.     /// </remarks>
  30.     internal class QilPatternFactory
  31.     {
  32.         private bool debug;
  33.         private QilFactory f;
  34.        
  35.         public QilPatternFactory(QilFactory f, bool debug)
  36.         {
  37.             Debug.Assert(f != null);
  38.             this.f = f;
  39.             this.debug = debug;
  40.         }
  41.        
  42.         public QilFactory BaseFactory {
  43.             get { return f; }
  44.         }
  45.         public bool IsDebug {
  46.             get { return this.debug; }
  47.         }
  48.        
  49.         #region Convenience methods
  50.        
  51.         public QilLiteral String(string val)
  52.         {
  53.             return f.LiteralString(val);
  54.         }
  55.        
  56.         public QilLiteral Int32(int val)
  57.         {
  58.             return f.LiteralInt32(val);
  59.         }
  60.        
  61.         public QilLiteral Double(double val)
  62.         {
  63.             return f.LiteralDouble(val);
  64.         }
  65.        
  66.         public QilName QName(string local, string uri, string prefix)
  67.         {
  68.             return f.LiteralQName(local, uri, prefix);
  69.         }
  70.        
  71.         public QilName QName(string local, string uri)
  72.         {
  73.             return f.LiteralQName(local, uri, System.String.Empty);
  74.         }
  75.        
  76.         public QilName QName(string local)
  77.         {
  78.             return f.LiteralQName(local, System.String.Empty, System.String.Empty);
  79.         }
  80.        
  81.         public QilNode Unknown(XmlQueryType t)
  82.         {
  83.             return f.Unknown(t);
  84.         }
  85.         #endregion
  86.        
  87.         #region meta
  88.         //-----------------------------------------------
  89.         // meta
  90.         //-----------------------------------------------
  91.         public QilExpression QilExpression(QilNode root, QilFactory factory)
  92.         {
  93.             return f.QilExpression(root, factory);
  94.         }
  95.        
  96.         public QilList FunctionList()
  97.         {
  98.             return f.FunctionList();
  99.         }
  100.        
  101.         public QilList GlobalVariableList()
  102.         {
  103.             return f.GlobalVariableList();
  104.         }
  105.        
  106.         public QilList GlobalParameterList()
  107.         {
  108.             return f.GlobalParameterList();
  109.         }
  110.        
  111.         public QilList ActualParameterList()
  112.         {
  113.             return f.ActualParameterList();
  114.         }
  115.        
  116.         public QilList ActualParameterList(QilNode arg1)
  117.         {
  118.             QilList result = f.ActualParameterList();
  119.             result.Add(arg1);
  120.             return result;
  121.         }
  122.        
  123.         public QilList ActualParameterList(QilNode arg1, QilNode arg2)
  124.         {
  125.             QilList result = f.ActualParameterList();
  126.             result.Add(arg1);
  127.             result.Add(arg2);
  128.             return result;
  129.         }
  130.        
  131.         public QilList ActualParameterList(params QilNode[] args)
  132.         {
  133.             return f.ActualParameterList(args);
  134.         }
  135.        
  136.         public QilList FormalParameterList()
  137.         {
  138.             return f.FormalParameterList();
  139.         }
  140.        
  141.         public QilList FormalParameterList(QilNode arg1)
  142.         {
  143.             QilList result = f.FormalParameterList();
  144.             result.Add(arg1);
  145.             return result;
  146.         }
  147.        
  148.         public QilList FormalParameterList(QilNode arg1, QilNode arg2)
  149.         {
  150.             QilList result = f.FormalParameterList();
  151.             result.Add(arg1);
  152.             result.Add(arg2);
  153.             return result;
  154.         }
  155.        
  156.         public QilList FormalParameterList(params QilNode[] args)
  157.         {
  158.             return f.FormalParameterList(args);
  159.         }
  160.        
  161.         public QilList SortKeyList()
  162.         {
  163.             return f.SortKeyList();
  164.         }
  165.        
  166.         public QilList SortKeyList(QilSortKey key)
  167.         {
  168.             QilList list = f.SortKeyList();
  169.             list.Add(key);
  170.             return list;
  171.         }
  172.        
  173.         public QilList BranchList(params QilNode[] args)
  174.         {
  175.             return f.BranchList(args);
  176.         }
  177.        
  178.         public QilNode OptimizeBarrier(QilNode child)
  179.         {
  180.             return f.OptimizeBarrier(child);
  181.         }
  182.        
  183.         #endregion // meta
  184.        
  185.         #region specials
  186.         //-----------------------------------------------
  187.         // specials
  188.         //-----------------------------------------------
  189.         public QilNode DataSource(QilNode name, QilNode baseUri)
  190.         {
  191.             return f.DataSource(name, baseUri);
  192.         }
  193.        
  194.         public QilNode Nop(QilNode child)
  195.         {
  196.             return f.Nop(child);
  197.         }
  198.        
  199.         public QilNode Error(QilNode text)
  200.         {
  201.             return f.Error(text);
  202.         }
  203.        
  204.         public QilNode Warning(QilNode text)
  205.         {
  206.             return f.Warning(text);
  207.         }
  208.        
  209.         #endregion // specials
  210.        
  211.         #region variables
  212.         //-----------------------------------------------
  213.         // variables
  214.         //-----------------------------------------------
  215.         public QilIterator For(QilNode binding)
  216.         {
  217.             return f.For(binding);
  218.         }
  219.        
  220.         public QilIterator Let(QilNode binding)
  221.         {
  222.             return f.Let(binding);
  223.         }
  224.        
  225.         public QilParameter Parameter(XmlQueryType t)
  226.         {
  227.             return f.Parameter(t);
  228.         }
  229.        
  230.         public QilParameter Parameter(QilNode defaultValue, QilName name, XmlQueryType t)
  231.         {
  232.             return f.Parameter(defaultValue, name, t);
  233.         }
  234.        
  235.         public QilNode PositionOf(QilIterator expr)
  236.         {
  237.             return f.PositionOf(expr);
  238.         }
  239.        
  240.         #endregion // variables
  241.        
  242.         #region literals
  243.         //-----------------------------------------------
  244.         // literals
  245.         //-----------------------------------------------
  246.         public QilNode True()
  247.         {
  248.             return f.True();
  249.         }
  250.        
  251.         public QilNode False()
  252.         {
  253.             return f.False();
  254.         }
  255.        
  256.         public QilNode Boolean(bool b)
  257.         {
  258.             return b ? this.True() : this.False();
  259.         }
  260.        
  261.         #endregion // literals
  262.        
  263.         #region boolean operators
  264.        
  265.         private static void CheckLogicArg(QilNode arg)
  266.         {
  267.             Debug.Assert(arg != null, "Argulent shouldn't be null");
  268.             Debug.Assert(arg.XmlType.TypeCode == XmlTypeCode.Boolean && arg.XmlType.IsSingleton, "The operand must be boolean-typed");
  269.         }
  270.        
  271.         public QilNode And(QilNode left, QilNode right)
  272.         {
  273.             CheckLogicArg(left);
  274.             CheckLogicArg(right);
  275.            
  276.             if (!debug) {
  277.                 // True, True => True (right) other, True => other (left)
  278.                 // True, False => False (right) other, False => False (right)
  279.                 // True, other => other (right) other, other => And
  280.                 if (left.NodeType == QilNodeType.True || right.NodeType == QilNodeType.False) {
  281.                     return right;
  282.                 }
  283.                 if (left.NodeType == QilNodeType.False || right.NodeType == QilNodeType.True) {
  284.                     return left;
  285.                 }
  286.             }
  287.             return f.And(left, right);
  288.         }
  289.        
  290.         public QilNode Or(QilNode left, QilNode right)
  291.         {
  292.             CheckLogicArg(left);
  293.             CheckLogicArg(right);
  294.            
  295.             if (!debug) {
  296.                 // True, True => True (left) other, True => True (right)
  297.                 // True, False => True (left) other, False => other (left)
  298.                 // True, other => True (left) other, other => Or
  299.                 if (left.NodeType == QilNodeType.True || right.NodeType == QilNodeType.False) {
  300.                     return left;
  301.                 }
  302.                 if (left.NodeType == QilNodeType.False || right.NodeType == QilNodeType.True) {
  303.                     return right;
  304.                 }
  305.             }
  306.             return f.Or(left, right);
  307.         }
  308.        
  309.         public QilNode Not(QilNode child)
  310.         {
  311.             if (!debug) {
  312.                 switch (child.NodeType) {
  313.                     case QilNodeType.True:
  314.                         return f.False();
  315.                     case QilNodeType.False:
  316.                         return f.True();
  317.                     case QilNodeType.Not:
  318.                         return ((QilUnary)child).Child;
  319.                 }
  320.             }
  321.             return f.Not(child);
  322.         }
  323.        
  324.         #endregion // boolean operators
  325.        
  326.         #region choice
  327.         //-----------------------------------------------
  328.         // choice
  329.         //-----------------------------------------------
  330.        
  331.         public QilNode Conditional(QilNode condition, QilNode trueBranch, QilNode falseBranch)
  332.         {
  333.             if (!debug) {
  334.                 switch (condition.NodeType) {
  335.                     case QilNodeType.True:
  336.                         return trueBranch;
  337.                     case QilNodeType.False:
  338.                         return falseBranch;
  339.                     case QilNodeType.Not:
  340.                         return this.Conditional(((QilUnary)condition).Child, falseBranch, trueBranch);
  341.                 }
  342.             }
  343.             return f.Conditional(condition, trueBranch, falseBranch);
  344.         }
  345.        
  346.         public QilNode Choice(QilNode expr, QilList branches)
  347.         {
  348.             if (!debug) {
  349.                 switch (branches.Count) {
  350.                     case 1:
  351.                         // If expr has no side effects, it will be eliminated by optimizer
  352.                         return f.Loop(f.Let(expr), branches[0]);
  353.                     case 2:
  354.                         return f.Conditional(f.Eq(expr, f.LiteralInt32(0)), branches[0], branches[1]);
  355.                 }
  356.             }
  357.             return f.Choice(expr, branches);
  358.         }
  359.        
  360.         #endregion // choice
  361.        
  362.         #region collection operators
  363.         //-----------------------------------------------
  364.         // collection operators
  365.         //-----------------------------------------------
  366.         public QilNode Length(QilNode child)
  367.         {
  368.             return f.Length(child);
  369.         }
  370.        
  371.         public QilNode Sequence()
  372.         {
  373.             return f.Sequence();
  374.         }
  375.        
  376.         public QilNode Sequence(QilNode child)
  377.         {
  378.             if (!debug) {
  379.                 return child;
  380.             }
  381.             QilList res = f.Sequence();
  382.             res.Add(child);
  383.             return res;
  384.         }
  385.        
  386.         public QilNode Sequence(QilNode child1, QilNode child2)
  387.         {
  388.             QilList res = f.Sequence();
  389.             res.Add(child1);
  390.             res.Add(child2);
  391.             return res;
  392.         }
  393.        
  394.         public QilNode Sequence(params QilNode[] args)
  395.         {
  396.             if (!debug) {
  397.                 switch (args.Length) {
  398.                     case 0:
  399.                         return f.Sequence();
  400.                     case 1:
  401.                         return args[0];
  402.                 }
  403.             }
  404.             QilList res = f.Sequence();
  405.             foreach (QilNode n in args)
  406.                 res.Add(n);
  407.             return res;
  408.         }
  409.        
  410.         public QilNode Union(QilNode left, QilNode right)
  411.         {
  412.             return f.Union(left, right);
  413.         }
  414.        
  415.         public QilNode Sum(QilNode collection)
  416.         {
  417.             return f.Sum(collection);
  418.         }
  419.         #endregion // collection operators
  420.        
  421.         #region arithmetic operators
  422.         //-----------------------------------------------
  423.         // arithmetic operators
  424.         //-----------------------------------------------
  425.         public QilNode Negate(QilNode child)
  426.         {
  427.             return f.Negate(child);
  428.         }
  429.        
  430.         public QilNode Add(QilNode left, QilNode right)
  431.         {
  432.             return f.Add(left, right);
  433.         }
  434.        
  435.         public QilNode Subtract(QilNode left, QilNode right)
  436.         {
  437.             return f.Subtract(left, right);
  438.         }
  439.        
  440.         public QilNode Multiply(QilNode left, QilNode right)
  441.         {
  442.             return f.Multiply(left, right);
  443.         }
  444.        
  445.         public QilNode Divide(QilNode left, QilNode right)
  446.         {
  447.             return f.Divide(left, right);
  448.         }
  449.        
  450.         public QilNode Modulo(QilNode left, QilNode right)
  451.         {
  452.             return f.Modulo(left, right);
  453.         }
  454.        
  455.         #endregion // arithmetic operators
  456.        
  457.         #region string operators
  458.         //-----------------------------------------------
  459.         // string operators
  460.         //-----------------------------------------------
  461.         public QilNode StrLength(QilNode str)
  462.         {
  463.             return f.StrLength(str);
  464.         }
  465.        
  466.         public QilNode StrConcat(QilNode values)
  467.         {
  468.             if (!debug) {
  469.                 if (values.XmlType.IsSingleton)
  470.                     return values;
  471.             }
  472.             return f.StrConcat(values);
  473.         }
  474.        
  475.         public QilNode StrConcat(params QilNode[] args)
  476.         {
  477.             return StrConcat((IList<QilNode>)args);
  478.         }
  479.        
  480.         public QilNode StrConcat(IList<QilNode> args)
  481.         {
  482.             if (!debug) {
  483.                 switch (args.Count) {
  484.                     case 0:
  485.                         return f.LiteralString(string.Empty);
  486.                     case 1:
  487.                         return StrConcat(args[0]);
  488.                 }
  489.             }
  490.             return StrConcat(f.Sequence(args));
  491.         }
  492.        
  493.         public QilNode StrParseQName(QilNode str, QilNode ns)
  494.         {
  495.             return f.StrParseQName(str, ns);
  496.         }
  497.         #endregion // string operators
  498.        
  499.         #region value comparison operators
  500.         //-----------------------------------------------
  501.         // value comparison operators
  502.         //-----------------------------------------------
  503.         public QilNode Ne(QilNode left, QilNode right)
  504.         {
  505.             return f.Ne(left, right);
  506.         }
  507.        
  508.         public QilNode Eq(QilNode left, QilNode right)
  509.         {
  510.             return f.Eq(left, right);
  511.         }
  512.        
  513.         public QilNode Gt(QilNode left, QilNode right)
  514.         {
  515.             return f.Gt(left, right);
  516.         }
  517.        
  518.         public QilNode Ge(QilNode left, QilNode right)
  519.         {
  520.             return f.Ge(left, right);
  521.         }
  522.        
  523.         public QilNode Lt(QilNode left, QilNode right)
  524.         {
  525.             return f.Lt(left, right);
  526.         }
  527.        
  528.         public QilNode Le(QilNode left, QilNode right)
  529.         {
  530.             return f.Le(left, right);
  531.         }
  532.        
  533.         #endregion // value comparison operators
  534.        
  535.         #region node comparison operators
  536.         //-----------------------------------------------
  537.         // node comparison operators
  538.         //-----------------------------------------------
  539.         public QilNode Is(QilNode left, QilNode right)
  540.         {
  541.             return f.Is(left, right);
  542.         }
  543.        
  544.         public QilNode After(QilNode left, QilNode right)
  545.         {
  546.             return f.After(left, right);
  547.         }
  548.        
  549.         public QilNode Before(QilNode left, QilNode right)
  550.         {
  551.             return f.Before(left, right);
  552.         }
  553.        
  554.         #endregion // node comparison operators
  555.        
  556.         #region loops
  557.         //-----------------------------------------------
  558.         // loops
  559.         //-----------------------------------------------
  560.         public QilNode Loop(QilIterator variable, QilNode body)
  561.         {
  562.             if (!debug) {
  563.                 //((Loop (For $Binding) ($Binding) ) => ($binding))
  564.                 if (body == variable.Binding) {
  565.                     return body;
  566.                 }
  567.             }
  568.             return f.Loop(variable, body);
  569.         }
  570.        
  571.         public QilNode Filter(QilIterator variable, QilNode expr)
  572.         {
  573.             if (!debug) {
  574.                 //((Filter (For $Binding) (True ) ) => ($binding))
  575.                 if (expr.NodeType == QilNodeType.True) {
  576.                     return variable.Binding;
  577.                 }
  578.                 // The following optimization is not safe if the iterator has side effects
  579.                 //((Filter (For $Binding) (False) ) => (Sequence))
  580.             }
  581.             return f.Filter(variable, expr);
  582.         }
  583.        
  584.         #endregion // loops
  585.        
  586.         #region sorting
  587.         //-----------------------------------------------
  588.         // sorting
  589.         //-----------------------------------------------
  590.         public QilNode Sort(QilIterator iter, QilNode keys)
  591.         {
  592.             return f.Sort(iter, keys);
  593.         }
  594.        
  595.         public QilSortKey SortKey(QilNode key, QilNode collation)
  596.         {
  597.             return f.SortKey(key, collation);
  598.         }
  599.        
  600.         public QilNode DocOrderDistinct(QilNode collection)
  601.         {
  602.             if (collection.NodeType == QilNodeType.DocOrderDistinct) {
  603.                 return collection;
  604.             }
  605.             return f.DocOrderDistinct(collection);
  606.         }
  607.        
  608.         #endregion // sorting
  609.        
  610.         #region function definition and invocation
  611.         //-----------------------------------------------
  612.         // function definition and invocation
  613.         //-----------------------------------------------
  614.         public QilFunction Function(QilList args, QilNode sideEffects, XmlQueryType resultType)
  615.         {
  616.             Debug.Assert(args.NodeType == QilNodeType.FormalParameterList);
  617.             return f.Function(args, sideEffects, resultType);
  618.         }
  619.         public QilFunction Function(QilList args, QilNode defn, QilNode sideEffects)
  620.         {
  621.             Debug.Assert(args.NodeType == QilNodeType.FormalParameterList);
  622.             return f.Function(args, defn, sideEffects, defn.XmlType);
  623.         }
  624.        
  625.         public QilNode Invoke(QilFunction func, QilList args)
  626.         {
  627.             Debug.Assert(args.NodeType == QilNodeType.ActualParameterList);
  628.             Debug.Assert(func.Arguments.Count == args.Count);
  629.             return f.Invoke(func, args);
  630.         }
  631.         #endregion // function definition and invocation
  632.        
  633.         #region XML navigation
  634.         //-----------------------------------------------
  635.         // XML navigation
  636.         //-----------------------------------------------
  637.         public QilNode Content(QilNode context)
  638.         {
  639.             return f.Content(context);
  640.         }
  641.        
  642.         public QilNode Parent(QilNode context)
  643.         {
  644.             return f.Parent(context);
  645.         }
  646.        
  647.         public QilNode Root(QilNode context)
  648.         {
  649.             return f.Root(context);
  650.         }
  651.        
  652.         public QilNode XmlContext()
  653.         {
  654.             return f.XmlContext();
  655.         }
  656.        
  657.         public QilNode Descendant(QilNode expr)
  658.         {
  659.             return f.Descendant(expr);
  660.         }
  661.        
  662.         public QilNode DescendantOrSelf(QilNode context)
  663.         {
  664.             return f.DescendantOrSelf(context);
  665.         }
  666.        
  667.         public QilNode Ancestor(QilNode expr)
  668.         {
  669.             return f.Ancestor(expr);
  670.         }
  671.        
  672.         public QilNode AncestorOrSelf(QilNode expr)
  673.         {
  674.             return f.AncestorOrSelf(expr);
  675.         }
  676.        
  677.         public QilNode Preceding(QilNode expr)
  678.         {
  679.             return f.Preceding(expr);
  680.         }
  681.        
  682.         public QilNode FollowingSibling(QilNode expr)
  683.         {
  684.             return f.FollowingSibling(expr);
  685.         }
  686.        
  687.         public QilNode PrecedingSibling(QilNode expr)
  688.         {
  689.             return f.PrecedingSibling(expr);
  690.         }
  691.        
  692.         public QilNode NodeRange(QilNode left, QilNode right)
  693.         {
  694.             return f.NodeRange(left, right);
  695.         }
  696.        
  697.         public QilBinary Deref(QilNode context, QilNode id)
  698.         {
  699.             return f.Deref(context, id);
  700.         }
  701.         #endregion // XML navigation
  702.        
  703.         #region XML construction
  704.         //-----------------------------------------------
  705.         // XML construction
  706.         //-----------------------------------------------
  707.         public QilNode ElementCtor(QilNode name, QilNode content)
  708.         {
  709.             return f.ElementCtor(name, content);
  710.         }
  711.        
  712.         public QilNode AttributeCtor(QilNode name, QilNode val)
  713.         {
  714.             return f.AttributeCtor(name, val);
  715.         }
  716.        
  717.         public QilNode CommentCtor(QilNode content)
  718.         {
  719.             return f.CommentCtor(content);
  720.         }
  721.        
  722.         public QilNode PICtor(QilNode name, QilNode content)
  723.         {
  724.             return f.PICtor(name, content);
  725.         }
  726.        
  727.         public QilNode TextCtor(QilNode content)
  728.         {
  729.             return f.TextCtor(content);
  730.         }
  731.        
  732.         public QilNode RawTextCtor(QilNode content)
  733.         {
  734.             return f.RawTextCtor(content);
  735.         }
  736.        
  737.         public QilNode DocumentCtor(QilNode child)
  738.         {
  739.             return f.DocumentCtor(child);
  740.         }
  741.        
  742.         public QilNode NamespaceDecl(QilNode prefix, QilNode uri)
  743.         {
  744.             return f.NamespaceDecl(prefix, uri);
  745.         }
  746.        
  747.         public QilNode RtfCtor(QilNode content, QilNode baseUri)
  748.         {
  749.             return f.RtfCtor(content, baseUri);
  750.         }
  751.        
  752.         #endregion // XML construction
  753.        
  754.         #region Node properties
  755.         //-----------------------------------------------
  756.         // Node properties
  757.         //-----------------------------------------------
  758.         public QilNode NameOf(QilNode expr)
  759.         {
  760.             return f.NameOf(expr);
  761.         }
  762.        
  763.         public QilNode LocalNameOf(QilNode expr)
  764.         {
  765.             return f.LocalNameOf(expr);
  766.         }
  767.        
  768.         public QilNode NamespaceUriOf(QilNode expr)
  769.         {
  770.             return f.NamespaceUriOf(expr);
  771.         }
  772.        
  773.         public QilNode PrefixOf(QilNode expr)
  774.         {
  775.             return f.PrefixOf(expr);
  776.         }
  777.        
  778.         #endregion // Node properties
  779.        
  780.         #region Type operators
  781.         //-----------------------------------------------
  782.         // Type operators
  783.         //-----------------------------------------------
  784.         public QilNode TypeAssert(QilNode expr, XmlQueryType t)
  785.         {
  786.             return f.TypeAssert(expr, t);
  787.         }
  788.        
  789.         public QilNode IsType(QilNode expr, XmlQueryType t)
  790.         {
  791.             Debug.Assert(t != null, "Type can't be null");
  792.             return f.IsType(expr, t);
  793.         }
  794.        
  795.         public QilNode IsEmpty(QilNode set)
  796.         {
  797.             return f.IsEmpty(set);
  798.         }
  799.        
  800.         #endregion // Type operators
  801.        
  802.         #region XPath operators
  803.         //-----------------------------------------------
  804.         // XPath operators
  805.         //-----------------------------------------------
  806.         public QilNode XPathNodeValue(QilNode expr)
  807.         {
  808.             return f.XPathNodeValue(expr);
  809.         }
  810.        
  811.         public QilNode XPathFollowing(QilNode expr)
  812.         {
  813.             return f.XPathFollowing(expr);
  814.         }
  815.        
  816.         public QilNode XPathNamespace(QilNode expr)
  817.         {
  818.             return f.XPathNamespace(expr);
  819.         }
  820.        
  821.         public QilNode XPathPreceding(QilNode expr)
  822.         {
  823.             return f.XPathPreceding(expr);
  824.         }
  825.        
  826.         #endregion // XPath operators
  827.        
  828.         #region XSLT
  829.         //-----------------------------------------------
  830.         // XSLT
  831.         //-----------------------------------------------
  832.         public QilNode XsltGenerateId(QilNode expr)
  833.         {
  834.             return f.XsltGenerateId(expr);
  835.         }
  836.        
  837.         public QilNode XsltInvokeEarlyBound(QilNode name, MethodInfo d, XmlQueryType t, IList<QilNode> args)
  838.         {
  839.             QilList list = f.ActualParameterList();
  840.             list.Add(args);
  841.             return f.XsltInvokeEarlyBound(name, f.LiteralObject(d), list, t);
  842.         }
  843.        
  844.         public QilNode XsltInvokeLateBound(QilNode name, IList<QilNode> args)
  845.         {
  846.             QilList list = f.ActualParameterList();
  847.             list.Add(args);
  848.             return f.XsltInvokeLateBound(name, list);
  849.         }
  850.        
  851.         public QilNode XsltCopy(QilNode expr, QilNode content)
  852.         {
  853.             return f.XsltCopy(expr, content);
  854.         }
  855.        
  856.         public QilNode XsltCopyOf(QilNode expr)
  857.         {
  858.             return f.XsltCopyOf(expr);
  859.         }
  860.        
  861.         public QilNode XsltConvert(QilNode expr, XmlQueryType t)
  862.         {
  863.             return f.XsltConvert(expr, t);
  864.         }
  865.        
  866.         #endregion // XSLT
  867.     }
  868. }

Developer Fusion