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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="QilFactory.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. namespace System.Xml.Xsl.Qil
  17. {
  18.     /// <summary>
  19.     /// Factory methods for constructing QilExpression nodes.
  20.     /// </summary>
  21.     /// <remarks>
  22.     /// See <see cref="http://dynamo/qil/qil.xml">the QIL functional specification</see> for documentation.
  23.     /// </remarks>
  24.     internal sealed class QilFactory
  25.     {
  26.         private QilTypeChecker typeCheck;
  27.        
  28.         public QilFactory()
  29.         {
  30.             this.typeCheck = new QilTypeChecker();
  31.         }
  32.        
  33.         public QilTypeChecker TypeChecker {
  34.             get { return this.typeCheck; }
  35.         }
  36.        
  37.        
  38.         //-----------------------------------------------
  39.         // Convenience methods
  40.         //-----------------------------------------------
  41.        
  42.         public QilExpression QilExpression(QilNode root, QilFactory factory)
  43.         {
  44.             QilExpression n = new QilExpression(QilNodeType.QilExpression, root, factory);
  45.             n.XmlType = this.typeCheck.CheckQilExpression(n);
  46.             TraceNode(n);
  47.             return n;
  48.         }
  49.        
  50.         public QilList FunctionList(IList<QilNode> values)
  51.         {
  52.             QilList seq = FunctionList();
  53.             seq.Add(values);
  54.             return seq;
  55.         }
  56.        
  57.         public QilList GlobalVariableList(IList<QilNode> values)
  58.         {
  59.             QilList seq = GlobalVariableList();
  60.             seq.Add(values);
  61.             return seq;
  62.         }
  63.        
  64.         public QilList GlobalParameterList(IList<QilNode> values)
  65.         {
  66.             QilList seq = GlobalParameterList();
  67.             seq.Add(values);
  68.             return seq;
  69.         }
  70.        
  71.         public QilList ActualParameterList(IList<QilNode> values)
  72.         {
  73.             QilList seq = ActualParameterList();
  74.             seq.Add(values);
  75.             return seq;
  76.         }
  77.        
  78.         public QilList FormalParameterList(IList<QilNode> values)
  79.         {
  80.             QilList seq = FormalParameterList();
  81.             seq.Add(values);
  82.             return seq;
  83.         }
  84.        
  85.         public QilList SortKeyList(IList<QilNode> values)
  86.         {
  87.             QilList seq = SortKeyList();
  88.             seq.Add(values);
  89.             return seq;
  90.         }
  91.        
  92.         public QilList BranchList(IList<QilNode> values)
  93.         {
  94.             QilList seq = BranchList();
  95.             seq.Add(values);
  96.             return seq;
  97.         }
  98.        
  99.         public QilList Sequence(IList<QilNode> values)
  100.         {
  101.             QilList seq = Sequence();
  102.             seq.Add(values);
  103.             return seq;
  104.         }
  105.        
  106.         public QilParameter Parameter(XmlQueryType xmlType)
  107.         {
  108.             return Parameter(null, null, xmlType);
  109.         }
  110.        
  111.         public QilStrConcat StrConcat(QilNode values)
  112.         {
  113.             return StrConcat(LiteralString(""), values);
  114.         }
  115.        
  116.         public QilName LiteralQName(string local)
  117.         {
  118.             return LiteralQName(local, string.Empty, string.Empty);
  119.         }
  120.        
  121.         public QilTargetType TypeAssert(QilNode expr, XmlQueryType xmlType)
  122.         {
  123.             return TypeAssert(expr, (QilNode)LiteralType(xmlType));
  124.         }
  125.        
  126.         public QilTargetType IsType(QilNode expr, XmlQueryType xmlType)
  127.         {
  128.             return IsType(expr, (QilNode)LiteralType(xmlType));
  129.         }
  130.        
  131.         public QilTargetType XsltConvert(QilNode expr, XmlQueryType xmlType)
  132.         {
  133.             return XsltConvert(expr, (QilNode)LiteralType(xmlType));
  134.         }
  135.        
  136.         public QilFunction Function(QilNode arguments, QilNode sideEffects, XmlQueryType xmlType)
  137.         {
  138.             return Function(arguments, Unknown(xmlType), sideEffects, xmlType);
  139.         }
  140.        
  141.        
  142.         #region AUTOGENERATED
  143.         #region meta
  144.         //-----------------------------------------------
  145.         // meta
  146.         //-----------------------------------------------
  147.         public QilExpression QilExpression(QilNode root)
  148.         {
  149.             QilExpression n = new QilExpression(QilNodeType.QilExpression, root);
  150.             n.XmlType = this.typeCheck.CheckQilExpression(n);
  151.             TraceNode(n);
  152.             return n;
  153.         }
  154.        
  155.         public QilList FunctionList()
  156.         {
  157.             QilList n = new QilList(QilNodeType.FunctionList);
  158.             n.XmlType = this.typeCheck.CheckFunctionList(n);
  159.             TraceNode(n);
  160.             return n;
  161.         }
  162.        
  163.         public QilList GlobalVariableList()
  164.         {
  165.             QilList n = new QilList(QilNodeType.GlobalVariableList);
  166.             n.XmlType = this.typeCheck.CheckGlobalVariableList(n);
  167.             TraceNode(n);
  168.             return n;
  169.         }
  170.        
  171.         public QilList GlobalParameterList()
  172.         {
  173.             QilList n = new QilList(QilNodeType.GlobalParameterList);
  174.             n.XmlType = this.typeCheck.CheckGlobalParameterList(n);
  175.             TraceNode(n);
  176.             return n;
  177.         }
  178.        
  179.         public QilList ActualParameterList()
  180.         {
  181.             QilList n = new QilList(QilNodeType.ActualParameterList);
  182.             n.XmlType = this.typeCheck.CheckActualParameterList(n);
  183.             TraceNode(n);
  184.             return n;
  185.         }
  186.        
  187.         public QilList FormalParameterList()
  188.         {
  189.             QilList n = new QilList(QilNodeType.FormalParameterList);
  190.             n.XmlType = this.typeCheck.CheckFormalParameterList(n);
  191.             TraceNode(n);
  192.             return n;
  193.         }
  194.        
  195.         public QilList SortKeyList()
  196.         {
  197.             QilList n = new QilList(QilNodeType.SortKeyList);
  198.             n.XmlType = this.typeCheck.CheckSortKeyList(n);
  199.             TraceNode(n);
  200.             return n;
  201.         }
  202.        
  203.         public QilList BranchList()
  204.         {
  205.             QilList n = new QilList(QilNodeType.BranchList);
  206.             n.XmlType = this.typeCheck.CheckBranchList(n);
  207.             TraceNode(n);
  208.             return n;
  209.         }
  210.        
  211.         public QilUnary OptimizeBarrier(QilNode child)
  212.         {
  213.             QilUnary n = new QilUnary(QilNodeType.OptimizeBarrier, child);
  214.             n.XmlType = this.typeCheck.CheckOptimizeBarrier(n);
  215.             TraceNode(n);
  216.             return n;
  217.         }
  218.        
  219.         public QilNode Unknown(XmlQueryType xmlType)
  220.         {
  221.             QilNode n = new QilNode(QilNodeType.Unknown, xmlType);
  222.             n.XmlType = this.typeCheck.CheckUnknown(n);
  223.             TraceNode(n);
  224.             return n;
  225.         }
  226.        
  227.         #endregion // meta
  228.        
  229.         #region specials
  230.         //-----------------------------------------------
  231.         // specials
  232.         //-----------------------------------------------
  233.         public QilDataSource DataSource(QilNode name, QilNode baseUri)
  234.         {
  235.             QilDataSource n = new QilDataSource(QilNodeType.DataSource, name, baseUri);
  236.             n.XmlType = this.typeCheck.CheckDataSource(n);
  237.             TraceNode(n);
  238.             return n;
  239.         }
  240.        
  241.         public QilUnary Nop(QilNode child)
  242.         {
  243.             QilUnary n = new QilUnary(QilNodeType.Nop, child);
  244.             n.XmlType = this.typeCheck.CheckNop(n);
  245.             TraceNode(n);
  246.             return n;
  247.         }
  248.        
  249.         public QilUnary Error(QilNode child)
  250.         {
  251.             QilUnary n = new QilUnary(QilNodeType.Error, child);
  252.             n.XmlType = this.typeCheck.CheckError(n);
  253.             TraceNode(n);
  254.             return n;
  255.         }
  256.        
  257.         public QilUnary Warning(QilNode child)
  258.         {
  259.             QilUnary n = new QilUnary(QilNodeType.Warning, child);
  260.             n.XmlType = this.typeCheck.CheckWarning(n);
  261.             TraceNode(n);
  262.             return n;
  263.         }
  264.        
  265.         #endregion // specials
  266.        
  267.         #region variables
  268.         //-----------------------------------------------
  269.         // variables
  270.         //-----------------------------------------------
  271.         public QilIterator For(QilNode binding)
  272.         {
  273.             QilIterator n = new QilIterator(QilNodeType.For, binding);
  274.             n.XmlType = this.typeCheck.CheckFor(n);
  275.             TraceNode(n);
  276.             return n;
  277.         }
  278.        
  279.         public QilIterator Let(QilNode binding)
  280.         {
  281.             QilIterator n = new QilIterator(QilNodeType.Let, binding);
  282.             n.XmlType = this.typeCheck.CheckLet(n);
  283.             TraceNode(n);
  284.             return n;
  285.         }
  286.        
  287.         public QilParameter Parameter(QilNode defaultValue, QilNode name, XmlQueryType xmlType)
  288.         {
  289.             QilParameter n = new QilParameter(QilNodeType.Parameter, defaultValue, name, xmlType);
  290.             n.XmlType = this.typeCheck.CheckParameter(n);
  291.             TraceNode(n);
  292.             return n;
  293.         }
  294.        
  295.         public QilUnary PositionOf(QilNode child)
  296.         {
  297.             QilUnary n = new QilUnary(QilNodeType.PositionOf, child);
  298.             n.XmlType = this.typeCheck.CheckPositionOf(n);
  299.             TraceNode(n);
  300.             return n;
  301.         }
  302.        
  303.         #endregion // variables
  304.        
  305.         #region literals
  306.         //-----------------------------------------------
  307.         // literals
  308.         //-----------------------------------------------
  309.         public QilNode True()
  310.         {
  311.             QilNode n = new QilNode(QilNodeType.True);
  312.             n.XmlType = this.typeCheck.CheckTrue(n);
  313.             TraceNode(n);
  314.             return n;
  315.         }
  316.        
  317.         public QilNode False()
  318.         {
  319.             QilNode n = new QilNode(QilNodeType.False);
  320.             n.XmlType = this.typeCheck.CheckFalse(n);
  321.             TraceNode(n);
  322.             return n;
  323.         }
  324.        
  325.         public QilLiteral LiteralString(string value)
  326.         {
  327.             QilLiteral n = new QilLiteral(QilNodeType.LiteralString, value);
  328.             n.XmlType = this.typeCheck.CheckLiteralString(n);
  329.             TraceNode(n);
  330.             return n;
  331.         }
  332.        
  333.         public QilLiteral LiteralInt32(int value)
  334.         {
  335.             QilLiteral n = new QilLiteral(QilNodeType.LiteralInt32, value);
  336.             n.XmlType = this.typeCheck.CheckLiteralInt32(n);
  337.             TraceNode(n);
  338.             return n;
  339.         }
  340.        
  341.         public QilLiteral LiteralInt64(long value)
  342.         {
  343.             QilLiteral n = new QilLiteral(QilNodeType.LiteralInt64, value);
  344.             n.XmlType = this.typeCheck.CheckLiteralInt64(n);
  345.             TraceNode(n);
  346.             return n;
  347.         }
  348.        
  349.         public QilLiteral LiteralDouble(double value)
  350.         {
  351.             QilLiteral n = new QilLiteral(QilNodeType.LiteralDouble, value);
  352.             n.XmlType = this.typeCheck.CheckLiteralDouble(n);
  353.             TraceNode(n);
  354.             return n;
  355.         }
  356.        
  357.         public QilLiteral LiteralDecimal(decimal value)
  358.         {
  359.             QilLiteral n = new QilLiteral(QilNodeType.LiteralDecimal, value);
  360.             n.XmlType = this.typeCheck.CheckLiteralDecimal(n);
  361.             TraceNode(n);
  362.             return n;
  363.         }
  364.        
  365.         public QilName LiteralQName(string localName, string namespaceUri, string prefix)
  366.         {
  367.             QilName n = new QilName(QilNodeType.LiteralQName, localName, namespaceUri, prefix);
  368.             n.XmlType = this.typeCheck.CheckLiteralQName(n);
  369.             TraceNode(n);
  370.             return n;
  371.         }
  372.        
  373.         public QilLiteral LiteralType(XmlQueryType value)
  374.         {
  375.             QilLiteral n = new QilLiteral(QilNodeType.LiteralType, value);
  376.             n.XmlType = this.typeCheck.CheckLiteralType(n);
  377.             TraceNode(n);
  378.             return n;
  379.         }
  380.        
  381.         public QilLiteral LiteralObject(object value)
  382.         {
  383.             QilLiteral n = new QilLiteral(QilNodeType.LiteralObject, value);
  384.             n.XmlType = this.typeCheck.CheckLiteralObject(n);
  385.             TraceNode(n);
  386.             return n;
  387.         }
  388.        
  389.         #endregion // literals
  390.        
  391.         #region boolean operators
  392.         //-----------------------------------------------
  393.         // boolean operators
  394.         //-----------------------------------------------
  395.         public QilBinary And(QilNode left, QilNode right)
  396.         {
  397.             QilBinary n = new QilBinary(QilNodeType.And, left, right);
  398.             n.XmlType = this.typeCheck.CheckAnd(n);
  399.             TraceNode(n);
  400.             return n;
  401.         }
  402.        
  403.         public QilBinary Or(QilNode left, QilNode right)
  404.         {
  405.             QilBinary n = new QilBinary(QilNodeType.Or, left, right);
  406.             n.XmlType = this.typeCheck.CheckOr(n);
  407.             TraceNode(n);
  408.             return n;
  409.         }
  410.        
  411.         public QilUnary Not(QilNode child)
  412.         {
  413.             QilUnary n = new QilUnary(QilNodeType.Not, child);
  414.             n.XmlType = this.typeCheck.CheckNot(n);
  415.             TraceNode(n);
  416.             return n;
  417.         }
  418.        
  419.         #endregion // boolean operators
  420.        
  421.         #region choice
  422.         //-----------------------------------------------
  423.         // choice
  424.         //-----------------------------------------------
  425.         public QilTernary Conditional(QilNode left, QilNode center, QilNode right)
  426.         {
  427.             QilTernary n = new QilTernary(QilNodeType.Conditional, left, center, right);
  428.             n.XmlType = this.typeCheck.CheckConditional(n);
  429.             TraceNode(n);
  430.             return n;
  431.         }
  432.        
  433.         public QilChoice Choice(QilNode expression, QilNode branches)
  434.         {
  435.             QilChoice n = new QilChoice(QilNodeType.Choice, expression, branches);
  436.             n.XmlType = this.typeCheck.CheckChoice(n);
  437.             TraceNode(n);
  438.             return n;
  439.         }
  440.        
  441.         #endregion // choice
  442.        
  443.         #region collection operators
  444.         //-----------------------------------------------
  445.         // collection operators
  446.         //-----------------------------------------------
  447.         public QilUnary Length(QilNode child)
  448.         {
  449.             QilUnary n = new QilUnary(QilNodeType.Length, child);
  450.             n.XmlType = this.typeCheck.CheckLength(n);
  451.             TraceNode(n);
  452.             return n;
  453.         }
  454.        
  455.         public QilList Sequence()
  456.         {
  457.             QilList n = new QilList(QilNodeType.Sequence);
  458.             n.XmlType = this.typeCheck.CheckSequence(n);
  459.             TraceNode(n);
  460.             return n;
  461.         }
  462.        
  463.         public QilBinary Union(QilNode left, QilNode right)
  464.         {
  465.             QilBinary n = new QilBinary(QilNodeType.Union, left, right);
  466.             n.XmlType = this.typeCheck.CheckUnion(n);
  467.             TraceNode(n);
  468.             return n;
  469.         }
  470.        
  471.         public QilBinary Intersection(QilNode left, QilNode right)
  472.         {
  473.             QilBinary n = new QilBinary(QilNodeType.Intersection, left, right);
  474.             n.XmlType = this.typeCheck.CheckIntersection(n);
  475.             TraceNode(n);
  476.             return n;
  477.         }
  478.        
  479.         public QilBinary Difference(QilNode left, QilNode right)
  480.         {
  481.             QilBinary n = new QilBinary(QilNodeType.Difference, left, right);
  482.             n.XmlType = this.typeCheck.CheckDifference(n);
  483.             TraceNode(n);
  484.             return n;
  485.         }
  486.        
  487.         public QilUnary Average(QilNode child)
  488.         {
  489.             QilUnary n = new QilUnary(QilNodeType.Average, child);
  490.             n.XmlType = this.typeCheck.CheckAverage(n);
  491.             TraceNode(n);
  492.             return n;
  493.         }
  494.        
  495.         public QilUnary Sum(QilNode child)
  496.         {
  497.             QilUnary n = new QilUnary(QilNodeType.Sum, child);
  498.             n.XmlType = this.typeCheck.CheckSum(n);
  499.             TraceNode(n);
  500.             return n;
  501.         }
  502.        
  503.         public QilUnary Minimum(QilNode child)
  504.         {
  505.             QilUnary n = new QilUnary(QilNodeType.Minimum, child);
  506.             n.XmlType = this.typeCheck.CheckMinimum(n);
  507.             TraceNode(n);
  508.             return n;
  509.         }
  510.        
  511.         public QilUnary Maximum(QilNode child)
  512.         {
  513.             QilUnary n = new QilUnary(QilNodeType.Maximum, child);
  514.             n.XmlType = this.typeCheck.CheckMaximum(n);
  515.             TraceNode(n);
  516.             return n;
  517.         }
  518.        
  519.         #endregion // collection operators
  520.        
  521.         #region arithmetic operators
  522.         //-----------------------------------------------
  523.         // arithmetic operators
  524.         //-----------------------------------------------
  525.         public QilUnary Negate(QilNode child)
  526.         {
  527.             QilUnary n = new QilUnary(QilNodeType.Negate, child);
  528.             n.XmlType = this.typeCheck.CheckNegate(n);
  529.             TraceNode(n);
  530.             return n;
  531.         }
  532.        
  533.         public QilBinary Add(QilNode left, QilNode right)
  534.         {
  535.             QilBinary n = new QilBinary(QilNodeType.Add, left, right);
  536.             n.XmlType = this.typeCheck.CheckAdd(n);
  537.             TraceNode(n);
  538.             return n;
  539.         }
  540.        
  541.         public QilBinary Subtract(QilNode left, QilNode right)
  542.         {
  543.             QilBinary n = new QilBinary(QilNodeType.Subtract, left, right);
  544.             n.XmlType = this.typeCheck.CheckSubtract(n);
  545.             TraceNode(n);
  546.             return n;
  547.         }
  548.        
  549.         public QilBinary Multiply(QilNode left, QilNode right)
  550.         {
  551.             QilBinary n = new QilBinary(QilNodeType.Multiply, left, right);
  552.             n.XmlType = this.typeCheck.CheckMultiply(n);
  553.             TraceNode(n);
  554.             return n;
  555.         }
  556.        
  557.         public QilBinary Divide(QilNode left, QilNode right)
  558.         {
  559.             QilBinary n = new QilBinary(QilNodeType.Divide, left, right);
  560.             n.XmlType = this.typeCheck.CheckDivide(n);
  561.             TraceNode(n);
  562.             return n;
  563.         }
  564.        
  565.         public QilBinary Modulo(QilNode left, QilNode right)
  566.         {
  567.             QilBinary n = new QilBinary(QilNodeType.Modulo, left, right);
  568.             n.XmlType = this.typeCheck.CheckModulo(n);
  569.             TraceNode(n);
  570.             return n;
  571.         }
  572.        
  573.         #endregion // arithmetic operators
  574.        
  575.         #region string operators
  576.         //-----------------------------------------------
  577.         // string operators
  578.         //-----------------------------------------------
  579.         public QilUnary StrLength(QilNode child)
  580.         {
  581.             QilUnary n = new QilUnary(QilNodeType.StrLength, child);
  582.             n.XmlType = this.typeCheck.CheckStrLength(n);
  583.             TraceNode(n);
  584.             return n;
  585.         }
  586.        
  587.         public QilStrConcat StrConcat(QilNode delimiter, QilNode values)
  588.         {
  589.             QilStrConcat n = new QilStrConcat(QilNodeType.StrConcat, delimiter, values);
  590.             n.XmlType = this.typeCheck.CheckStrConcat(n);
  591.             TraceNode(n);
  592.             return n;
  593.         }
  594.        
  595.         public QilBinary StrParseQName(QilNode left, QilNode right)
  596.         {
  597.             QilBinary n = new QilBinary(QilNodeType.StrParseQName, left, right);
  598.             n.XmlType = this.typeCheck.CheckStrParseQName(n);
  599.             TraceNode(n);
  600.             return n;
  601.         }
  602.        
  603.         #endregion // string operators
  604.        
  605.         #region value comparison operators
  606.         //-----------------------------------------------
  607.         // value comparison operators
  608.         //-----------------------------------------------
  609.         public QilBinary Ne(QilNode left, QilNode right)
  610.         {
  611.             QilBinary n = new QilBinary(QilNodeType.Ne, left, right);
  612.             n.XmlType = this.typeCheck.CheckNe(n);
  613.             TraceNode(n);
  614.             return n;
  615.         }
  616.        
  617.         public QilBinary Eq(QilNode left, QilNode right)
  618.         {
  619.             QilBinary n = new QilBinary(QilNodeType.Eq, left, right);
  620.             n.XmlType = this.typeCheck.CheckEq(n);
  621.             TraceNode(n);
  622.             return n;
  623.         }
  624.        
  625.         public QilBinary Gt(QilNode left, QilNode right)
  626.         {
  627.             QilBinary n = new QilBinary(QilNodeType.Gt, left, right);
  628.             n.XmlType = this.typeCheck.CheckGt(n);
  629.             TraceNode(n);
  630.             return n;
  631.         }
  632.        
  633.         public QilBinary Ge(QilNode left, QilNode right)
  634.         {
  635.             QilBinary n = new QilBinary(QilNodeType.Ge, left, right);
  636.             n.XmlType = this.typeCheck.CheckGe(n);
  637.             TraceNode(n);
  638.             return n;
  639.         }
  640.        
  641.         public QilBinary Lt(QilNode left, QilNode right)
  642.         {
  643.             QilBinary n = new QilBinary(QilNodeType.Lt, left, right);
  644.             n.XmlType = this.typeCheck.CheckLt(n);
  645.             TraceNode(n);
  646.             return n;
  647.         }
  648.        
  649.         public QilBinary Le(QilNode left, QilNode right)
  650.         {
  651.             QilBinary n = new QilBinary(QilNodeType.Le, left, right);
  652.             n.XmlType = this.typeCheck.CheckLe(n);
  653.             TraceNode(n);
  654.             return n;
  655.         }
  656.        
  657.         #endregion // value comparison operators
  658.        
  659.         #region node comparison operators
  660.         //-----------------------------------------------
  661.         // node comparison operators
  662.         //-----------------------------------------------
  663.         public QilBinary Is(QilNode left, QilNode right)
  664.         {
  665.             QilBinary n = new QilBinary(QilNodeType.Is, left, right);
  666.             n.XmlType = this.typeCheck.CheckIs(n);
  667.             TraceNode(n);
  668.             return n;
  669.         }
  670.        
  671.         public QilBinary After(QilNode left, QilNode right)
  672.         {
  673.             QilBinary n = new QilBinary(QilNodeType.After, left, right);
  674.             n.XmlType = this.typeCheck.CheckAfter(n);
  675.             TraceNode(n);
  676.             return n;
  677.         }
  678.        
  679.         public QilBinary Before(QilNode left, QilNode right)
  680.         {
  681.             QilBinary n = new QilBinary(QilNodeType.Before, left, right);
  682.             n.XmlType = this.typeCheck.CheckBefore(n);
  683.             TraceNode(n);
  684.             return n;
  685.         }
  686.        
  687.         #endregion // node comparison operators
  688.        
  689.         #region loops
  690.         //-----------------------------------------------
  691.         // loops
  692.         //-----------------------------------------------
  693.         public QilLoop Loop(QilNode variable, QilNode body)
  694.         {
  695.             QilLoop n = new QilLoop(QilNodeType.Loop, variable, body);
  696.             n.XmlType = this.typeCheck.CheckLoop(n);
  697.             TraceNode(n);
  698.             return n;
  699.         }
  700.        
  701.         public QilLoop Filter(QilNode variable, QilNode body)
  702.         {
  703.             QilLoop n = new QilLoop(QilNodeType.Filter, variable, body);
  704.             n.XmlType = this.typeCheck.CheckFilter(n);
  705.             TraceNode(n);
  706.             return n;
  707.         }
  708.        
  709.         #endregion // loops
  710.        
  711.         #region sorting
  712.         //-----------------------------------------------
  713.         // sorting
  714.         //-----------------------------------------------
  715.         public QilLoop Sort(QilNode variable, QilNode body)
  716.         {
  717.             QilLoop n = new QilLoop(QilNodeType.Sort, variable, body);
  718.             n.XmlType = this.typeCheck.CheckSort(n);
  719.             TraceNode(n);
  720.             return n;
  721.         }
  722.        
  723.         public QilSortKey SortKey(QilNode key, QilNode collation)
  724.         {
  725.             QilSortKey n = new QilSortKey(QilNodeType.SortKey, key, collation);
  726.             n.XmlType = this.typeCheck.CheckSortKey(n);
  727.             TraceNode(n);
  728.             return n;
  729.         }
  730.        
  731.         public QilUnary DocOrderDistinct(QilNode child)
  732.         {
  733.             QilUnary n = new QilUnary(QilNodeType.DocOrderDistinct, child);
  734.             n.XmlType = this.typeCheck.CheckDocOrderDistinct(n);
  735.             TraceNode(n);
  736.             return n;
  737.         }
  738.        
  739.         #endregion // sorting
  740.        
  741.         #region function definition and invocation
  742.         //-----------------------------------------------
  743.         // function definition and invocation
  744.         //-----------------------------------------------
  745.         public QilFunction Function(QilNode arguments, QilNode definition, QilNode sideEffects, XmlQueryType xmlType)
  746.         {
  747.             QilFunction n = new QilFunction(QilNodeType.Function, arguments, definition, sideEffects, xmlType);
  748.             n.XmlType = this.typeCheck.CheckFunction(n);
  749.             TraceNode(n);
  750.             return n;
  751.         }
  752.        
  753.         public QilInvoke Invoke(QilNode function, QilNode arguments)
  754.         {
  755.             QilInvoke n = new QilInvoke(QilNodeType.Invoke, function, arguments);
  756.             n.XmlType = this.typeCheck.CheckInvoke(n);
  757.             TraceNode(n);
  758.             return n;
  759.         }
  760.        
  761.         #endregion // function definition and invocation
  762.        
  763.         #region XML navigation
  764.         //-----------------------------------------------
  765.         // XML navigation
  766.         //-----------------------------------------------
  767.         public QilUnary Content(QilNode child)
  768.         {
  769.             QilUnary n = new QilUnary(QilNodeType.Content, child);
  770.             n.XmlType = this.typeCheck.CheckContent(n);
  771.             TraceNode(n);
  772.             return n;
  773.         }
  774.        
  775.         public QilBinary Attribute(QilNode left, QilNode right)
  776.         {
  777.             QilBinary n = new QilBinary(QilNodeType.Attribute, left, right);
  778.             n.XmlType = this.typeCheck.CheckAttribute(n);
  779.             TraceNode(n);
  780.             return n;
  781.         }
  782.        
  783.         public QilUnary Parent(QilNode child)
  784.         {
  785.             QilUnary n = new QilUnary(QilNodeType.Parent, child);
  786.             n.XmlType = this.typeCheck.CheckParent(n);
  787.             TraceNode(n);
  788.             return n;
  789.         }
  790.        
  791.         public QilUnary Root(QilNode child)
  792.         {
  793.             QilUnary n = new QilUnary(QilNodeType.Root, child);
  794.             n.XmlType = this.typeCheck.CheckRoot(n);
  795.             TraceNode(n);
  796.             return n;
  797.         }
  798.        
  799.         public QilNode XmlContext()
  800.         {
  801.             QilNode n = new QilNode(QilNodeType.XmlContext);
  802.             n.XmlType = this.typeCheck.CheckXmlContext(n);
  803.             TraceNode(n);
  804.             return n;
  805.         }
  806.        
  807.         public QilUnary Descendant(QilNode child)
  808.         {
  809.             QilUnary n = new QilUnary(QilNodeType.Descendant, child);
  810.             n.XmlType = this.typeCheck.CheckDescendant(n);
  811.             TraceNode(n);
  812.             return n;
  813.         }
  814.        
  815.         public QilUnary DescendantOrSelf(QilNode child)
  816.         {
  817.             QilUnary n = new QilUnary(QilNodeType.DescendantOrSelf, child);
  818.             n.XmlType = this.typeCheck.CheckDescendantOrSelf(n);
  819.             TraceNode(n);
  820.             return n;
  821.         }
  822.        
  823.         public QilUnary Ancestor(QilNode child)
  824.         {
  825.             QilUnary n = new QilUnary(QilNodeType.Ancestor, child);
  826.             n.XmlType = this.typeCheck.CheckAncestor(n);
  827.             TraceNode(n);
  828.             return n;
  829.         }
  830.        
  831.         public QilUnary AncestorOrSelf(QilNode child)
  832.         {
  833.             QilUnary n = new QilUnary(QilNodeType.AncestorOrSelf, child);
  834.             n.XmlType = this.typeCheck.CheckAncestorOrSelf(n);
  835.             TraceNode(n);
  836.             return n;
  837.         }
  838.        
  839.         public QilUnary Preceding(QilNode child)
  840.         {
  841.             QilUnary n = new QilUnary(QilNodeType.Preceding, child);
  842.             n.XmlType = this.typeCheck.CheckPreceding(n);
  843.             TraceNode(n);
  844.             return n;
  845.         }
  846.        
  847.         public QilUnary FollowingSibling(QilNode child)
  848.         {
  849.             QilUnary n = new QilUnary(QilNodeType.FollowingSibling, child);
  850.             n.XmlType = this.typeCheck.CheckFollowingSibling(n);
  851.             TraceNode(n);
  852.             return n;
  853.         }
  854.        
  855.         public QilUnary PrecedingSibling(QilNode child)
  856.         {
  857.             QilUnary n = new QilUnary(QilNodeType.PrecedingSibling, child);
  858.             n.XmlType = this.typeCheck.CheckPrecedingSibling(n);
  859.             TraceNode(n);
  860.             return n;
  861.         }
  862.        
  863.         public QilBinary NodeRange(QilNode left, QilNode right)
  864.         {
  865.             QilBinary n = new QilBinary(QilNodeType.NodeRange, left, right);
  866.             n.XmlType = this.typeCheck.CheckNodeRange(n);
  867.             TraceNode(n);
  868.             return n;
  869.         }
  870.        
  871.         public QilBinary Deref(QilNode left, QilNode right)
  872.         {
  873.             QilBinary n = new QilBinary(QilNodeType.Deref, left, right);
  874.             n.XmlType = this.typeCheck.CheckDeref(n);
  875.             TraceNode(n);
  876.             return n;
  877.         }
  878.        
  879.         #endregion // XML navigation
  880.        
  881.         #region XML construction
  882.         //-----------------------------------------------
  883.         // XML construction
  884.         //-----------------------------------------------
  885.         public QilBinary ElementCtor(QilNode left, QilNode right)
  886.         {
  887.             QilBinary n = new QilBinary(QilNodeType.ElementCtor, left, right);
  888.             n.XmlType = this.typeCheck.CheckElementCtor(n);
  889.             TraceNode(n);
  890.             return n;
  891.         }
  892.        
  893.         public QilBinary AttributeCtor(QilNode left, QilNode right)
  894.         {
  895.             QilBinary n = new QilBinary(QilNodeType.AttributeCtor, left, right);
  896.             n.XmlType = this.typeCheck.CheckAttributeCtor(n);
  897.             TraceNode(n);
  898.             return n;
  899.         }
  900.        
  901.         public QilUnary CommentCtor(QilNode child)
  902.         {
  903.             QilUnary n = new QilUnary(QilNodeType.CommentCtor, child);
  904.             n.XmlType = this.typeCheck.CheckCommentCtor(n);
  905.             TraceNode(n);
  906.             return n;
  907.         }
  908.        
  909.         public QilBinary PICtor(QilNode left, QilNode right)
  910.         {
  911.             QilBinary n = new QilBinary(QilNodeType.PICtor, left, right);
  912.             n.XmlType = this.typeCheck.CheckPICtor(n);
  913.             TraceNode(n);
  914.             return n;
  915.         }
  916.        
  917.         public QilUnary TextCtor(QilNode child)
  918.         {
  919.             QilUnary n = new QilUnary(QilNodeType.TextCtor, child);
  920.             n.XmlType = this.typeCheck.CheckTextCtor(n);
  921.             TraceNode(n);
  922.             return n;
  923.         }
  924.        
  925.         public QilUnary RawTextCtor(QilNode child)
  926.         {
  927.             QilUnary n = new QilUnary(QilNodeType.RawTextCtor, child);
  928.             n.XmlType = this.typeCheck.CheckRawTextCtor(n);
  929.             TraceNode(n);
  930.             return n;
  931.         }
  932.        
  933.         public QilUnary DocumentCtor(QilNode child)
  934.         {
  935.             QilUnary n = new QilUnary(QilNodeType.DocumentCtor, child);
  936.             n.XmlType = this.typeCheck.CheckDocumentCtor(n);
  937.             TraceNode(n);
  938.             return n;
  939.         }
  940.        
  941.         public QilBinary NamespaceDecl(QilNode left, QilNode right)
  942.         {
  943.             QilBinary n = new QilBinary(QilNodeType.NamespaceDecl, left, right);
  944.             n.XmlType = this.typeCheck.CheckNamespaceDecl(n);
  945.             TraceNode(n);
  946.             return n;
  947.         }
  948.        
  949.         public QilBinary RtfCtor(QilNode left, QilNode right)
  950.         {
  951.             QilBinary n = new QilBinary(QilNodeType.RtfCtor, left, right);
  952.             n.XmlType = this.typeCheck.CheckRtfCtor(n);
  953.             TraceNode(n);
  954.             return n;
  955.         }
  956.        
  957.         #endregion // XML construction
  958.        
  959.         #region Node properties
  960.         //-----------------------------------------------
  961.         // Node properties
  962.         //-----------------------------------------------
  963.         public QilUnary NameOf(QilNode child)
  964.         {
  965.             QilUnary n = new QilUnary(QilNodeType.NameOf, child);
  966.             n.XmlType = this.typeCheck.CheckNameOf(n);
  967.             TraceNode(n);
  968.             return n;
  969.         }
  970.        
  971.         public QilUnary LocalNameOf(QilNode child)
  972.         {
  973.             QilUnary n = new QilUnary(QilNodeType.LocalNameOf, child);
  974.             n.XmlType = this.typeCheck.CheckLocalNameOf(n);
  975.             TraceNode(n);
  976.             return n;
  977.         }
  978.        
  979.         public QilUnary NamespaceUriOf(QilNode child)
  980.         {
  981.             QilUnary n = new QilUnary(QilNodeType.NamespaceUriOf, child);
  982.             n.XmlType = this.typeCheck.CheckNamespaceUriOf(n);
  983.             TraceNode(n);
  984.             return n;
  985.         }
  986.        
  987.         public QilUnary PrefixOf(QilNode child)
  988.         {
  989.             QilUnary n = new QilUnary(QilNodeType.PrefixOf, child);
  990.             n.XmlType = this.typeCheck.CheckPrefixOf(n);
  991.             TraceNode(n);
  992.             return n;
  993.         }
  994.        
  995.         #endregion // Node properties
  996.        
  997.         #region Type operators
  998.         //-----------------------------------------------
  999.         // Type operators
  1000.         //-----------------------------------------------
  1001.         public QilTargetType TypeAssert(QilNode source, QilNode targetType)
  1002.         {
  1003.             QilTargetType n = new QilTargetType(QilNodeType.TypeAssert, source, targetType);
  1004.             n.XmlType = this.typeCheck.CheckTypeAssert(n);
  1005.             TraceNode(n);
  1006.             return n;
  1007.         }
  1008.        
  1009.         public QilTargetType IsType(QilNode source, QilNode targetType)
  1010.         {
  1011.             QilTargetType n = new QilTargetType(QilNodeType.IsType, source, targetType);
  1012.             n.XmlType = this.typeCheck.CheckIsType(n);
  1013.             TraceNode(n);
  1014.             return n;
  1015.         }
  1016.        
  1017.         public QilUnary IsEmpty(QilNode child)
  1018.         {
  1019.             QilUnary n = new QilUnary(QilNodeType.IsEmpty, child);
  1020.             n.XmlType = this.typeCheck.CheckIsEmpty(n);
  1021.             TraceNode(n);
  1022.             return n;
  1023.         }
  1024.        
  1025.         #endregion // Type operators
  1026.        
  1027.         #region XPath operators
  1028.         //-----------------------------------------------
  1029.         // XPath operators
  1030.         //-----------------------------------------------
  1031.         public QilUnary XPathNodeValue(QilNode child)
  1032.         {
  1033.             QilUnary n = new QilUnary(QilNodeType.XPathNodeValue, child);
  1034.             n.XmlType = this.typeCheck.CheckXPathNodeValue(n);
  1035.             TraceNode(n);
  1036.             return n;
  1037.         }
  1038.        
  1039.         public QilUnary XPathFollowing(QilNode child)
  1040.         {
  1041.             QilUnary n = new QilUnary(QilNodeType.XPathFollowing, child);
  1042.             n.XmlType = this.typeCheck.CheckXPathFollowing(n);
  1043.             TraceNode(n);
  1044.             return n;
  1045.         }
  1046.        
  1047.         public QilUnary XPathPreceding(QilNode child)
  1048.         {
  1049.             QilUnary n = new QilUnary(QilNodeType.XPathPreceding, child);
  1050.             n.XmlType = this.typeCheck.CheckXPathPreceding(n);
  1051.             TraceNode(n);
  1052.             return n;
  1053.         }
  1054.        
  1055.         public QilUnary XPathNamespace(QilNode child)
  1056.         {
  1057.             QilUnary n = new QilUnary(QilNodeType.XPathNamespace, child);
  1058.             n.XmlType = this.typeCheck.CheckXPathNamespace(n);
  1059.             TraceNode(n);
  1060.             return n;
  1061.         }
  1062.        
  1063.         #endregion // XPath operators
  1064.        
  1065.         #region XSLT
  1066.         //-----------------------------------------------
  1067.         // XSLT
  1068.         //-----------------------------------------------
  1069.         public QilUnary XsltGenerateId(QilNode child)
  1070.         {
  1071.             QilUnary n = new QilUnary(QilNodeType.XsltGenerateId, child);
  1072.             n.XmlType = this.typeCheck.CheckXsltGenerateId(n);
  1073.             TraceNode(n);
  1074.             return n;
  1075.         }
  1076.        
  1077.         public QilInvokeLateBound XsltInvokeLateBound(QilNode name, QilNode arguments)
  1078.         {
  1079.             QilInvokeLateBound n = new QilInvokeLateBound(QilNodeType.XsltInvokeLateBound, name, arguments);
  1080.             n.XmlType = this.typeCheck.CheckXsltInvokeLateBound(n);
  1081.             TraceNode(n);
  1082.             return n;
  1083.         }
  1084.        
  1085.         public QilInvokeEarlyBound XsltInvokeEarlyBound(QilNode name, QilNode clrMethod, QilNode arguments, XmlQueryType xmlType)
  1086.         {
  1087.             QilInvokeEarlyBound n = new QilInvokeEarlyBound(QilNodeType.XsltInvokeEarlyBound, name, clrMethod, arguments, xmlType);
  1088.             n.XmlType = this.typeCheck.CheckXsltInvokeEarlyBound(n);
  1089.             TraceNode(n);
  1090.             return n;
  1091.         }
  1092.        
  1093.         public QilBinary XsltCopy(QilNode left, QilNode right)
  1094.         {
  1095.             QilBinary n = new QilBinary(QilNodeType.XsltCopy, left, right);
  1096.             n.XmlType = this.typeCheck.CheckXsltCopy(n);
  1097.             TraceNode(n);
  1098.             return n;
  1099.         }
  1100.        
  1101.         public QilUnary XsltCopyOf(QilNode child)
  1102.         {
  1103.             QilUnary n = new QilUnary(QilNodeType.XsltCopyOf, child);
  1104.             n.XmlType = this.typeCheck.CheckXsltCopyOf(n);
  1105.             TraceNode(n);
  1106.             return n;
  1107.         }
  1108.        
  1109.         public QilTargetType XsltConvert(QilNode source, QilNode targetType)
  1110.         {
  1111.             QilTargetType n = new QilTargetType(QilNodeType.XsltConvert, source, targetType);
  1112.             n.XmlType = this.typeCheck.CheckXsltConvert(n);
  1113.             TraceNode(n);
  1114.             return n;
  1115.         }
  1116.        
  1117.         #endregion // XSLT
  1118.        
  1119.         #endregion
  1120.        
  1121.         #region Diagnostic Support
  1122.         #if QIL_TRACE_NODE_CREATION
  1123.         internal sealed class Diagnostics
  1124.         {
  1125.             private int nodecnt = 0;
  1126.             private ArrayList nodelist = new ArrayList();
  1127.            
  1128.             public ArrayList NodeTable {
  1129.                 get { return nodelist; }
  1130.             }
  1131.            
  1132.             public void AddNode(QilNode n)
  1133.             {
  1134.                 nodelist.Add(n);
  1135.                 n.NodeId = nodecnt++;
  1136.                 StackTrace st = new StackTrace(true);
  1137.                 for (int i = 1; i < st.FrameCount; i++) {
  1138.                     StackFrame sf = st.GetFrame(i);
  1139.                     Type mt = sf.GetMethod().DeclaringType;
  1140.                     if (mt != typeof(QilFactory) && mt != typeof(QilPatternFactory)) {
  1141.                         n.NodeLocation = mt.FullName + "." + sf.GetMethod().Name + " (" + sf.GetFileName() + ": " + sf.GetFileLineNumber() + "," + sf.GetFileColumnNumber() + ")";
  1142.                         break;
  1143.                     }
  1144.                 }
  1145.             }
  1146.         }
  1147.        
  1148.         private Diagnostics diag = new Diagnostics();
  1149.        
  1150.         public Diagnostics DebugInfo {
  1151.             get { return diag; }
  1152.             set { diag = value; }
  1153.         }
  1154.         #endif
  1155.        
  1156.         [System.Diagnostics.Conditional("QIL_TRACE_NODE_CREATION")]
  1157.         public void TraceNode(QilNode n)
  1158.         {
  1159.             #if QIL_TRACE_NODE_CREATION
  1160.             this.diag.AddNode(n);
  1161.             #endif
  1162.         }
  1163.         #endregion
  1164.     }
  1165. }

Developer Fusion