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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="QilVisitor.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;
  16. using System.Collections.Generic;
  17. namespace System.Xml.Xsl.Qil
  18. {
  19.    
  20.     /// <summary>A base internal class for QIL visitors.</summary>
  21.     /// <remarks>
  22.     /// <p>QilVisitor is a base internal class for traversing QIL graphs. Override individual Visit methods to change
  23.     /// behavior for only certain node types; override Visit() to change behavior for all node types at once; override
  24.     /// VisitChildren() to change the algorithm for iterating and visiting children.</p>
  25.     /// <p>Subclasses may also find it useful to annotate the tree during visitation.</p>
  26.     /// </remarks>
  27.     internal abstract class QilVisitor
  28.     {
  29.        
  30.         //-----------------------------------------------
  31.         // QilVisitor methods (manually generated)
  32.         //-----------------------------------------------
  33.        
  34.         /// <summary>
  35.         /// If a reference is passed to the Visit() method, it is assumed to be the definition.
  36.         /// This method assumes it is a reference to a definition.
  37.         /// For example, if a Let node is visited, is it the Let definition or a reference to the
  38.         /// the Let definition? Without context, it is ambiguous. This method allows a caller
  39.         /// to disambiguate.
  40.         /// </summary>
  41.         protected virtual QilNode VisitAssumeReference(QilNode expr)
  42.         {
  43.             if (expr is QilReference)
  44.                 return VisitReference(expr);
  45.            
  46.             return Visit(expr);
  47.         }
  48.        
  49.         /// <summary>
  50.         /// Visit all children of "parent". By default, take care to avoid circular visits.
  51.         /// </summary>
  52.         protected virtual QilNode VisitChildren(QilNode parent)
  53.         {
  54.             for (int i = 0; i < parent.Count; i++) {
  55.                 // If child is a reference, then call VisitReference instead of Visit in order to avoid circular visits.
  56.                 if (IsReference(parent, i))
  57.                     VisitReference(parent[i]);
  58.                 else
  59.                     Visit(parent[i]);
  60.             }
  61.            
  62.             return parent;
  63.         }
  64.        
  65.         /// <summary>
  66.         /// Visit all children of "parent". Take care to avoid circular visits.
  67.         /// </summary>
  68.         protected virtual bool IsReference(QilNode parent, int childNum)
  69.         {
  70.             QilNode child = parent[childNum];
  71.            
  72.             if (child != null) {
  73.                 switch (child.NodeType) {
  74.                     case QilNodeType.For:
  75.                     case QilNodeType.Let:
  76.                     case QilNodeType.Parameter:
  77.                         // Is this a reference or a definition?
  78.                         switch (parent.NodeType) {
  79.                             case QilNodeType.Loop:
  80.                             case QilNodeType.Filter:
  81.                             case QilNodeType.Sort:
  82.                                 // Second child of these node types is a reference; first child is a definition
  83.                                 return childNum == 1;
  84.                             case QilNodeType.GlobalVariableList:
  85.                             case QilNodeType.GlobalParameterList:
  86.                             case QilNodeType.FormalParameterList:
  87.                                
  88.                                 // All children of definition lists are definitions
  89.                                 return false;
  90.                         }
  91.                        
  92.                         // All other cases are references
  93.                         return true;
  94.                     case QilNodeType.Function:
  95.                        
  96.                         // If parent is an Invoke node, then visit a reference to the function
  97.                         return parent.NodeType == QilNodeType.Invoke;
  98.                 }
  99.             }
  100.            
  101.             return false;
  102.         }
  103.        
  104.        
  105.         //-----------------------------------------------
  106.         // QilVisitor methods (auto-generated)
  107.         //-----------------------------------------------
  108.        
  109.         // Do not edit this region
  110.         #region AUTOGENERATED
  111.         protected virtual QilNode Visit(QilNode n)
  112.         {
  113.             if (n == null)
  114.                 return VisitNull();
  115.            
  116.             switch (n.NodeType) {
  117.                 case QilNodeType.QilExpression:
  118.                     return VisitQilExpression((QilExpression)n);
  119.                 case QilNodeType.FunctionList:
  120.                     return VisitFunctionList((QilList)n);
  121.                 case QilNodeType.GlobalVariableList:
  122.                     return VisitGlobalVariableList((QilList)n);
  123.                 case QilNodeType.GlobalParameterList:
  124.                     return VisitGlobalParameterList((QilList)n);
  125.                 case QilNodeType.ActualParameterList:
  126.                     return VisitActualParameterList((QilList)n);
  127.                 case QilNodeType.FormalParameterList:
  128.                     return VisitFormalParameterList((QilList)n);
  129.                 case QilNodeType.SortKeyList:
  130.                     return VisitSortKeyList((QilList)n);
  131.                 case QilNodeType.BranchList:
  132.                     return VisitBranchList((QilList)n);
  133.                 case QilNodeType.OptimizeBarrier:
  134.                     return VisitOptimizeBarrier((QilUnary)n);
  135.                 case QilNodeType.Unknown:
  136.                     return VisitUnknown(n);
  137.                 case QilNodeType.DataSource:
  138.                    
  139.                     return VisitDataSource((QilDataSource)n);
  140.                 case QilNodeType.Nop:
  141.                     return VisitNop((QilUnary)n);
  142.                 case QilNodeType.Error:
  143.                     return VisitError((QilUnary)n);
  144.                 case QilNodeType.Warning:
  145.                     return VisitWarning((QilUnary)n);
  146.                 case QilNodeType.For:
  147.                    
  148.                     return VisitFor((QilIterator)n);
  149.                 case QilNodeType.Let:
  150.                     return VisitLet((QilIterator)n);
  151.                 case QilNodeType.Parameter:
  152.                     return VisitParameter((QilParameter)n);
  153.                 case QilNodeType.PositionOf:
  154.                     return VisitPositionOf((QilUnary)n);
  155.                 case QilNodeType.True:
  156.                    
  157.                     return VisitTrue(n);
  158.                 case QilNodeType.False:
  159.                     return VisitFalse(n);
  160.                 case QilNodeType.LiteralString:
  161.                     return VisitLiteralString((QilLiteral)n);
  162.                 case QilNodeType.LiteralInt32:
  163.                     return VisitLiteralInt32((QilLiteral)n);
  164.                 case QilNodeType.LiteralInt64:
  165.                     return VisitLiteralInt64((QilLiteral)n);
  166.                 case QilNodeType.LiteralDouble:
  167.                     return VisitLiteralDouble((QilLiteral)n);
  168.                 case QilNodeType.LiteralDecimal:
  169.                     return VisitLiteralDecimal((QilLiteral)n);
  170.                 case QilNodeType.LiteralQName:
  171.                     return VisitLiteralQName((QilName)n);
  172.                 case QilNodeType.LiteralType:
  173.                     return VisitLiteralType((QilLiteral)n);
  174.                 case QilNodeType.LiteralObject:
  175.                     return VisitLiteralObject((QilLiteral)n);
  176.                 case QilNodeType.And:
  177.                    
  178.                     return VisitAnd((QilBinary)n);
  179.                 case QilNodeType.Or:
  180.                     return VisitOr((QilBinary)n);
  181.                 case QilNodeType.Not:
  182.                     return VisitNot((QilUnary)n);
  183.                 case QilNodeType.Conditional:
  184.                    
  185.                     return VisitConditional((QilTernary)n);
  186.                 case QilNodeType.Choice:
  187.                     return VisitChoice((QilChoice)n);
  188.                 case QilNodeType.Length:
  189.                    
  190.                     return VisitLength((QilUnary)n);
  191.                 case QilNodeType.Sequence:
  192.                     return VisitSequence((QilList)n);
  193.                 case QilNodeType.Union:
  194.                     return VisitUnion((QilBinary)n);
  195.                 case QilNodeType.Intersection:
  196.                     return VisitIntersection((QilBinary)n);
  197.                 case QilNodeType.Difference:
  198.                     return VisitDifference((QilBinary)n);
  199.                 case QilNodeType.Average:
  200.                     return VisitAverage((QilUnary)n);
  201.                 case QilNodeType.Sum:
  202.                     return VisitSum((QilUnary)n);
  203.                 case QilNodeType.Minimum:
  204.                     return VisitMinimum((QilUnary)n);
  205.                 case QilNodeType.Maximum:
  206.                     return VisitMaximum((QilUnary)n);
  207.                 case QilNodeType.Negate:
  208.                    
  209.                     return VisitNegate((QilUnary)n);
  210.                 case QilNodeType.Add:
  211.                     return VisitAdd((QilBinary)n);
  212.                 case QilNodeType.Subtract:
  213.                     return VisitSubtract((QilBinary)n);
  214.                 case QilNodeType.Multiply:
  215.                     return VisitMultiply((QilBinary)n);
  216.                 case QilNodeType.Divide:
  217.                     return VisitDivide((QilBinary)n);
  218.                 case QilNodeType.Modulo:
  219.                     return VisitModulo((QilBinary)n);
  220.                 case QilNodeType.StrLength:
  221.                    
  222.                     return VisitStrLength((QilUnary)n);
  223.                 case QilNodeType.StrConcat:
  224.                     return VisitStrConcat((QilStrConcat)n);
  225.                 case QilNodeType.StrParseQName:
  226.                     return VisitStrParseQName((QilBinary)n);
  227.                 case QilNodeType.Ne:
  228.                    
  229.                     return VisitNe((QilBinary)n);
  230.                 case QilNodeType.Eq:
  231.                     return VisitEq((QilBinary)n);
  232.                 case QilNodeType.Gt:
  233.                     return VisitGt((QilBinary)n);
  234.                 case QilNodeType.Ge:
  235.                     return VisitGe((QilBinary)n);
  236.                 case QilNodeType.Lt:
  237.                     return VisitLt((QilBinary)n);
  238.                 case QilNodeType.Le:
  239.                     return VisitLe((QilBinary)n);
  240.                 case QilNodeType.Is:
  241.                    
  242.                     return VisitIs((QilBinary)n);
  243.                 case QilNodeType.After:
  244.                     return VisitAfter((QilBinary)n);
  245.                 case QilNodeType.Before:
  246.                     return VisitBefore((QilBinary)n);
  247.                 case QilNodeType.Loop:
  248.                    
  249.                     return VisitLoop((QilLoop)n);
  250.                 case QilNodeType.Filter:
  251.                     return VisitFilter((QilLoop)n);
  252.                 case QilNodeType.Sort:
  253.                    
  254.                     return VisitSort((QilLoop)n);
  255.                 case QilNodeType.SortKey:
  256.                     return VisitSortKey((QilSortKey)n);
  257.                 case QilNodeType.DocOrderDistinct:
  258.                     return VisitDocOrderDistinct((QilUnary)n);
  259.                 case QilNodeType.Function:
  260.                    
  261.                     return VisitFunction((QilFunction)n);
  262.                 case QilNodeType.Invoke:
  263.                     return VisitInvoke((QilInvoke)n);
  264.                 case QilNodeType.Content:
  265.                    
  266.                     return VisitContent((QilUnary)n);
  267.                 case QilNodeType.Attribute:
  268.                     return VisitAttribute((QilBinary)n);
  269.                 case QilNodeType.Parent:
  270.                     return VisitParent((QilUnary)n);
  271.                 case QilNodeType.Root:
  272.                     return VisitRoot((QilUnary)n);
  273.                 case QilNodeType.XmlContext:
  274.                     return VisitXmlContext(n);
  275.                 case QilNodeType.Descendant:
  276.                     return VisitDescendant((QilUnary)n);
  277.                 case QilNodeType.DescendantOrSelf:
  278.                     return VisitDescendantOrSelf((QilUnary)n);
  279.                 case QilNodeType.Ancestor:
  280.                     return VisitAncestor((QilUnary)n);
  281.                 case QilNodeType.AncestorOrSelf:
  282.                     return VisitAncestorOrSelf((QilUnary)n);
  283.                 case QilNodeType.Preceding:
  284.                     return VisitPreceding((QilUnary)n);
  285.                 case QilNodeType.FollowingSibling:
  286.                     return VisitFollowingSibling((QilUnary)n);
  287.                 case QilNodeType.PrecedingSibling:
  288.                     return VisitPrecedingSibling((QilUnary)n);
  289.                 case QilNodeType.NodeRange:
  290.                     return VisitNodeRange((QilBinary)n);
  291.                 case QilNodeType.Deref:
  292.                     return VisitDeref((QilBinary)n);
  293.                 case QilNodeType.ElementCtor:
  294.                    
  295.                     return VisitElementCtor((QilBinary)n);
  296.                 case QilNodeType.AttributeCtor:
  297.                     return VisitAttributeCtor((QilBinary)n);
  298.                 case QilNodeType.CommentCtor:
  299.                     return VisitCommentCtor((QilUnary)n);
  300.                 case QilNodeType.PICtor:
  301.                     return VisitPICtor((QilBinary)n);
  302.                 case QilNodeType.TextCtor:
  303.                     return VisitTextCtor((QilUnary)n);
  304.                 case QilNodeType.RawTextCtor:
  305.                     return VisitRawTextCtor((QilUnary)n);
  306.                 case QilNodeType.DocumentCtor:
  307.                     return VisitDocumentCtor((QilUnary)n);
  308.                 case QilNodeType.NamespaceDecl:
  309.                     return VisitNamespaceDecl((QilBinary)n);
  310.                 case QilNodeType.RtfCtor:
  311.                     return VisitRtfCtor((QilBinary)n);
  312.                 case QilNodeType.NameOf:
  313.                    
  314.                     return VisitNameOf((QilUnary)n);
  315.                 case QilNodeType.LocalNameOf:
  316.                     return VisitLocalNameOf((QilUnary)n);
  317.                 case QilNodeType.NamespaceUriOf:
  318.                     return VisitNamespaceUriOf((QilUnary)n);
  319.                 case QilNodeType.PrefixOf:
  320.                     return VisitPrefixOf((QilUnary)n);
  321.                 case QilNodeType.TypeAssert:
  322.                    
  323.                     return VisitTypeAssert((QilTargetType)n);
  324.                 case QilNodeType.IsType:
  325.                     return VisitIsType((QilTargetType)n);
  326.                 case QilNodeType.IsEmpty:
  327.                     return VisitIsEmpty((QilUnary)n);
  328.                 case QilNodeType.XPathNodeValue:
  329.                    
  330.                     return VisitXPathNodeValue((QilUnary)n);
  331.                 case QilNodeType.XPathFollowing:
  332.                     return VisitXPathFollowing((QilUnary)n);
  333.                 case QilNodeType.XPathPreceding:
  334.                     return VisitXPathPreceding((QilUnary)n);
  335.                 case QilNodeType.XPathNamespace:
  336.                     return VisitXPathNamespace((QilUnary)n);
  337.                 case QilNodeType.XsltGenerateId:
  338.                    
  339.                     return VisitXsltGenerateId((QilUnary)n);
  340.                 case QilNodeType.XsltInvokeLateBound:
  341.                     return VisitXsltInvokeLateBound((QilInvokeLateBound)n);
  342.                 case QilNodeType.XsltInvokeEarlyBound:
  343.                     return VisitXsltInvokeEarlyBound((QilInvokeEarlyBound)n);
  344.                 case QilNodeType.XsltCopy:
  345.                     return VisitXsltCopy((QilBinary)n);
  346.                 case QilNodeType.XsltCopyOf:
  347.                     return VisitXsltCopyOf((QilUnary)n);
  348.                 case QilNodeType.XsltConvert:
  349.                     return VisitXsltConvert((QilTargetType)n);
  350.                 default:
  351.                    
  352.                     return VisitUnknown(n);
  353.             }
  354.         }
  355.        
  356.         protected virtual QilNode VisitReference(QilNode n)
  357.         {
  358.             if (n == null)
  359.                 return VisitNull();
  360.            
  361.             switch (n.NodeType) {
  362.                 case QilNodeType.For:
  363.                     return VisitForReference((QilIterator)n);
  364.                 case QilNodeType.Let:
  365.                     return VisitLetReference((QilIterator)n);
  366.                 case QilNodeType.Parameter:
  367.                     return VisitParameterReference((QilParameter)n);
  368.                 case QilNodeType.Function:
  369.                    
  370.                     return VisitFunctionReference((QilFunction)n);
  371.                 default:
  372.                    
  373.                     return VisitUnknown(n);
  374.             }
  375.         }
  376.        
  377.         protected virtual QilNode VisitNull()
  378.         {
  379.             return null;
  380.         }
  381.        
  382.         #region meta
  383.         protected virtual QilNode VisitQilExpression(QilExpression n)
  384.         {
  385.             return VisitChildren(n);
  386.         }
  387.         protected virtual QilNode VisitFunctionList(QilList n)
  388.         {
  389.             return VisitChildren(n);
  390.         }
  391.         protected virtual QilNode VisitGlobalVariableList(QilList n)
  392.         {
  393.             return VisitChildren(n);
  394.         }
  395.         protected virtual QilNode VisitGlobalParameterList(QilList n)
  396.         {
  397.             return VisitChildren(n);
  398.         }
  399.         protected virtual QilNode VisitActualParameterList(QilList n)
  400.         {
  401.             return VisitChildren(n);
  402.         }
  403.         protected virtual QilNode VisitFormalParameterList(QilList n)
  404.         {
  405.             return VisitChildren(n);
  406.         }
  407.         protected virtual QilNode VisitSortKeyList(QilList n)
  408.         {
  409.             return VisitChildren(n);
  410.         }
  411.         protected virtual QilNode VisitBranchList(QilList n)
  412.         {
  413.             return VisitChildren(n);
  414.         }
  415.         protected virtual QilNode VisitOptimizeBarrier(QilUnary n)
  416.         {
  417.             return VisitChildren(n);
  418.         }
  419.         protected virtual QilNode VisitUnknown(QilNode n)
  420.         {
  421.             return VisitChildren(n);
  422.         }
  423.         #endregion
  424.        
  425.         #region specials
  426.         protected virtual QilNode VisitDataSource(QilDataSource n)
  427.         {
  428.             return VisitChildren(n);
  429.         }
  430.         protected virtual QilNode VisitNop(QilUnary n)
  431.         {
  432.             return VisitChildren(n);
  433.         }
  434.         protected virtual QilNode VisitError(QilUnary n)
  435.         {
  436.             return VisitChildren(n);
  437.         }
  438.         protected virtual QilNode VisitWarning(QilUnary n)
  439.         {
  440.             return VisitChildren(n);
  441.         }
  442.         #endregion
  443.        
  444.         #region variables
  445.         protected virtual QilNode VisitFor(QilIterator n)
  446.         {
  447.             return VisitChildren(n);
  448.         }
  449.         protected virtual QilNode VisitForReference(QilIterator n)
  450.         {
  451.             return n;
  452.         }
  453.         protected virtual QilNode VisitLet(QilIterator n)
  454.         {
  455.             return VisitChildren(n);
  456.         }
  457.         protected virtual QilNode VisitLetReference(QilIterator n)
  458.         {
  459.             return n;
  460.         }
  461.         protected virtual QilNode VisitParameter(QilParameter n)
  462.         {
  463.             return VisitChildren(n);
  464.         }
  465.         protected virtual QilNode VisitParameterReference(QilParameter n)
  466.         {
  467.             return n;
  468.         }
  469.         protected virtual QilNode VisitPositionOf(QilUnary n)
  470.         {
  471.             return VisitChildren(n);
  472.         }
  473.         #endregion
  474.        
  475.         #region literals
  476.         protected virtual QilNode VisitTrue(QilNode n)
  477.         {
  478.             return VisitChildren(n);
  479.         }
  480.         protected virtual QilNode VisitFalse(QilNode n)
  481.         {
  482.             return VisitChildren(n);
  483.         }
  484.         protected virtual QilNode VisitLiteralString(QilLiteral n)
  485.         {
  486.             return VisitChildren(n);
  487.         }
  488.         protected virtual QilNode VisitLiteralInt32(QilLiteral n)
  489.         {
  490.             return VisitChildren(n);
  491.         }
  492.         protected virtual QilNode VisitLiteralInt64(QilLiteral n)
  493.         {
  494.             return VisitChildren(n);
  495.         }
  496.         protected virtual QilNode VisitLiteralDouble(QilLiteral n)
  497.         {
  498.             return VisitChildren(n);
  499.         }
  500.         protected virtual QilNode VisitLiteralDecimal(QilLiteral n)
  501.         {
  502.             return VisitChildren(n);
  503.         }
  504.         protected virtual QilNode VisitLiteralQName(QilName n)
  505.         {
  506.             return VisitChildren(n);
  507.         }
  508.         protected virtual QilNode VisitLiteralType(QilLiteral n)
  509.         {
  510.             return VisitChildren(n);
  511.         }
  512.         protected virtual QilNode VisitLiteralObject(QilLiteral n)
  513.         {
  514.             return VisitChildren(n);
  515.         }
  516.         #endregion
  517.        
  518.         #region boolean operators
  519.         protected virtual QilNode VisitAnd(QilBinary n)
  520.         {
  521.             return VisitChildren(n);
  522.         }
  523.         protected virtual QilNode VisitOr(QilBinary n)
  524.         {
  525.             return VisitChildren(n);
  526.         }
  527.         protected virtual QilNode VisitNot(QilUnary n)
  528.         {
  529.             return VisitChildren(n);
  530.         }
  531.         #endregion
  532.        
  533.         #region choice
  534.         protected virtual QilNode VisitConditional(QilTernary n)
  535.         {
  536.             return VisitChildren(n);
  537.         }
  538.         protected virtual QilNode VisitChoice(QilChoice n)
  539.         {
  540.             return VisitChildren(n);
  541.         }
  542.         #endregion
  543.        
  544.         #region collection operators
  545.         protected virtual QilNode VisitLength(QilUnary n)
  546.         {
  547.             return VisitChildren(n);
  548.         }
  549.         protected virtual QilNode VisitSequence(QilList n)
  550.         {
  551.             return VisitChildren(n);
  552.         }
  553.         protected virtual QilNode VisitUnion(QilBinary n)
  554.         {
  555.             return VisitChildren(n);
  556.         }
  557.         protected virtual QilNode VisitIntersection(QilBinary n)
  558.         {
  559.             return VisitChildren(n);
  560.         }
  561.         protected virtual QilNode VisitDifference(QilBinary n)
  562.         {
  563.             return VisitChildren(n);
  564.         }
  565.         protected virtual QilNode VisitAverage(QilUnary n)
  566.         {
  567.             return VisitChildren(n);
  568.         }
  569.         protected virtual QilNode VisitSum(QilUnary n)
  570.         {
  571.             return VisitChildren(n);
  572.         }
  573.         protected virtual QilNode VisitMinimum(QilUnary n)
  574.         {
  575.             return VisitChildren(n);
  576.         }
  577.         protected virtual QilNode VisitMaximum(QilUnary n)
  578.         {
  579.             return VisitChildren(n);
  580.         }
  581.         #endregion
  582.        
  583.         #region arithmetic operators
  584.         protected virtual QilNode VisitNegate(QilUnary n)
  585.         {
  586.             return VisitChildren(n);
  587.         }
  588.         protected virtual QilNode VisitAdd(QilBinary n)
  589.         {
  590.             return VisitChildren(n);
  591.         }
  592.         protected virtual QilNode VisitSubtract(QilBinary n)
  593.         {
  594.             return VisitChildren(n);
  595.         }
  596.         protected virtual QilNode VisitMultiply(QilBinary n)
  597.         {
  598.             return VisitChildren(n);
  599.         }
  600.         protected virtual QilNode VisitDivide(QilBinary n)
  601.         {
  602.             return VisitChildren(n);
  603.         }
  604.         protected virtual QilNode VisitModulo(QilBinary n)
  605.         {
  606.             return VisitChildren(n);
  607.         }
  608.         #endregion
  609.        
  610.         #region string operators
  611.         protected virtual QilNode VisitStrLength(QilUnary n)
  612.         {
  613.             return VisitChildren(n);
  614.         }
  615.         protected virtual QilNode VisitStrConcat(QilStrConcat n)
  616.         {
  617.             return VisitChildren(n);
  618.         }
  619.         protected virtual QilNode VisitStrParseQName(QilBinary n)
  620.         {
  621.             return VisitChildren(n);
  622.         }
  623.         #endregion
  624.        
  625.         #region value comparison operators
  626.         protected virtual QilNode VisitNe(QilBinary n)
  627.         {
  628.             return VisitChildren(n);
  629.         }
  630.         protected virtual QilNode VisitEq(QilBinary n)
  631.         {
  632.             return VisitChildren(n);
  633.         }
  634.         protected virtual QilNode VisitGt(QilBinary n)
  635.         {
  636.             return VisitChildren(n);
  637.         }
  638.         protected virtual QilNode VisitGe(QilBinary n)
  639.         {
  640.             return VisitChildren(n);
  641.         }
  642.         protected virtual QilNode VisitLt(QilBinary n)
  643.         {
  644.             return VisitChildren(n);
  645.         }
  646.         protected virtual QilNode VisitLe(QilBinary n)
  647.         {
  648.             return VisitChildren(n);
  649.         }
  650.         #endregion
  651.        
  652.         #region node comparison operators
  653.         protected virtual QilNode VisitIs(QilBinary n)
  654.         {
  655.             return VisitChildren(n);
  656.         }
  657.         protected virtual QilNode VisitAfter(QilBinary n)
  658.         {
  659.             return VisitChildren(n);
  660.         }
  661.         protected virtual QilNode VisitBefore(QilBinary n)
  662.         {
  663.             return VisitChildren(n);
  664.         }
  665.         #endregion
  666.        
  667.         #region loops
  668.         protected virtual QilNode VisitLoop(QilLoop n)
  669.         {
  670.             return VisitChildren(n);
  671.         }
  672.         protected virtual QilNode VisitFilter(QilLoop n)
  673.         {
  674.             return VisitChildren(n);
  675.         }
  676.         #endregion
  677.        
  678.         #region sorting
  679.         protected virtual QilNode VisitSort(QilLoop n)
  680.         {
  681.             return VisitChildren(n);
  682.         }
  683.         protected virtual QilNode VisitSortKey(QilSortKey n)
  684.         {
  685.             return VisitChildren(n);
  686.         }
  687.         protected virtual QilNode VisitDocOrderDistinct(QilUnary n)
  688.         {
  689.             return VisitChildren(n);
  690.         }
  691.         #endregion
  692.        
  693.         #region function definition and invocation
  694.         protected virtual QilNode VisitFunction(QilFunction n)
  695.         {
  696.             return VisitChildren(n);
  697.         }
  698.         protected virtual QilNode VisitFunctionReference(QilFunction n)
  699.         {
  700.             return n;
  701.         }
  702.         protected virtual QilNode VisitInvoke(QilInvoke n)
  703.         {
  704.             return VisitChildren(n);
  705.         }
  706.         #endregion
  707.        
  708.         #region XML navigation
  709.         protected virtual QilNode VisitContent(QilUnary n)
  710.         {
  711.             return VisitChildren(n);
  712.         }
  713.         protected virtual QilNode VisitAttribute(QilBinary n)
  714.         {
  715.             return VisitChildren(n);
  716.         }
  717.         protected virtual QilNode VisitParent(QilUnary n)
  718.         {
  719.             return VisitChildren(n);
  720.         }
  721.         protected virtual QilNode VisitRoot(QilUnary n)
  722.         {
  723.             return VisitChildren(n);
  724.         }
  725.         protected virtual QilNode VisitXmlContext(QilNode n)
  726.         {
  727.             return VisitChildren(n);
  728.         }
  729.         protected virtual QilNode VisitDescendant(QilUnary n)
  730.         {
  731.             return VisitChildren(n);
  732.         }
  733.         protected virtual QilNode VisitDescendantOrSelf(QilUnary n)
  734.         {
  735.             return VisitChildren(n);
  736.         }
  737.         protected virtual QilNode VisitAncestor(QilUnary n)
  738.         {
  739.             return VisitChildren(n);
  740.         }
  741.         protected virtual QilNode VisitAncestorOrSelf(QilUnary n)
  742.         {
  743.             return VisitChildren(n);
  744.         }
  745.         protected virtual QilNode VisitPreceding(QilUnary n)
  746.         {
  747.             return VisitChildren(n);
  748.         }
  749.         protected virtual QilNode VisitFollowingSibling(QilUnary n)
  750.         {
  751.             return VisitChildren(n);
  752.         }
  753.         protected virtual QilNode VisitPrecedingSibling(QilUnary n)
  754.         {
  755.             return VisitChildren(n);
  756.         }
  757.         protected virtual QilNode VisitNodeRange(QilBinary n)
  758.         {
  759.             return VisitChildren(n);
  760.         }
  761.         protected virtual QilNode VisitDeref(QilBinary n)
  762.         {
  763.             return VisitChildren(n);
  764.         }
  765.         #endregion
  766.        
  767.         #region XML construction
  768.         protected virtual QilNode VisitElementCtor(QilBinary n)
  769.         {
  770.             return VisitChildren(n);
  771.         }
  772.         protected virtual QilNode VisitAttributeCtor(QilBinary n)
  773.         {
  774.             return VisitChildren(n);
  775.         }
  776.         protected virtual QilNode VisitCommentCtor(QilUnary n)
  777.         {
  778.             return VisitChildren(n);
  779.         }
  780.         protected virtual QilNode VisitPICtor(QilBinary n)
  781.         {
  782.             return VisitChildren(n);
  783.         }
  784.         protected virtual QilNode VisitTextCtor(QilUnary n)
  785.         {
  786.             return VisitChildren(n);
  787.         }
  788.         protected virtual QilNode VisitRawTextCtor(QilUnary n)
  789.         {
  790.             return VisitChildren(n);
  791.         }
  792.         protected virtual QilNode VisitDocumentCtor(QilUnary n)
  793.         {
  794.             return VisitChildren(n);
  795.         }
  796.         protected virtual QilNode VisitNamespaceDecl(QilBinary n)
  797.         {
  798.             return VisitChildren(n);
  799.         }
  800.         protected virtual QilNode VisitRtfCtor(QilBinary n)
  801.         {
  802.             return VisitChildren(n);
  803.         }
  804.         #endregion
  805.        
  806.         #region Node properties
  807.         protected virtual QilNode VisitNameOf(QilUnary n)
  808.         {
  809.             return VisitChildren(n);
  810.         }
  811.         protected virtual QilNode VisitLocalNameOf(QilUnary n)
  812.         {
  813.             return VisitChildren(n);
  814.         }
  815.         protected virtual QilNode VisitNamespaceUriOf(QilUnary n)
  816.         {
  817.             return VisitChildren(n);
  818.         }
  819.         protected virtual QilNode VisitPrefixOf(QilUnary n)
  820.         {
  821.             return VisitChildren(n);
  822.         }
  823.         #endregion
  824.        
  825.         #region Type operators
  826.         protected virtual QilNode VisitTypeAssert(QilTargetType n)
  827.         {
  828.             return VisitChildren(n);
  829.         }
  830.         protected virtual QilNode VisitIsType(QilTargetType n)
  831.         {
  832.             return VisitChildren(n);
  833.         }
  834.         protected virtual QilNode VisitIsEmpty(QilUnary n)
  835.         {
  836.             return VisitChildren(n);
  837.         }
  838.         #endregion
  839.        
  840.         #region XPath operators
  841.         protected virtual QilNode VisitXPathNodeValue(QilUnary n)
  842.         {
  843.             return VisitChildren(n);
  844.         }
  845.         protected virtual QilNode VisitXPathFollowing(QilUnary n)
  846.         {
  847.             return VisitChildren(n);
  848.         }
  849.         protected virtual QilNode VisitXPathPreceding(QilUnary n)
  850.         {
  851.             return VisitChildren(n);
  852.         }
  853.         protected virtual QilNode VisitXPathNamespace(QilUnary n)
  854.         {
  855.             return VisitChildren(n);
  856.         }
  857.         #endregion
  858.        
  859.         #region XSLT
  860.         protected virtual QilNode VisitXsltGenerateId(QilUnary n)
  861.         {
  862.             return VisitChildren(n);
  863.         }
  864.         protected virtual QilNode VisitXsltInvokeLateBound(QilInvokeLateBound n)
  865.         {
  866.             return VisitChildren(n);
  867.         }
  868.         protected virtual QilNode VisitXsltInvokeEarlyBound(QilInvokeEarlyBound n)
  869.         {
  870.             return VisitChildren(n);
  871.         }
  872.         protected virtual QilNode VisitXsltCopy(QilBinary n)
  873.         {
  874.             return VisitChildren(n);
  875.         }
  876.         protected virtual QilNode VisitXsltCopyOf(QilUnary n)
  877.         {
  878.             return VisitChildren(n);
  879.         }
  880.         protected virtual QilNode VisitXsltConvert(QilTargetType n)
  881.         {
  882.             return VisitChildren(n);
  883.         }
  884.         #endregion
  885.        
  886.         #endregion // AUTOGENERATED
  887.     }
  888. }

Developer Fusion