C# Class System.Xml.Xsl.IlGen.XmlILVisitor

Bind values in the "ndLet" expression to a non-stack location that can later be referenced.

Visits the specified QilExpression graph and generates MSIL code.

Generate a query plan for the QilExpression subgraph.

Generate code for QilNodeType.Add.

Generate code for QilNodeType.VisitAfter.

Find physical query plan for QilNodeType.Ancestor.

Find physical query plan for QilNodeType.AncestorOrSelf.

Generate code for QilNodeType.And.

BranchingContext.OnFalse context: (expr1) and (expr2) ==> if (!expr1) goto LabelParent; if (!expr2) goto LabelParent; BranchingContext.OnTrue context: (expr1) and (expr2) ==> if (!expr1) goto LabelTemp; if (expr1) goto LabelParent; LabelTemp: BranchingContext.None context: (expr1) and (expr2) ==> if (!expr1) goto LabelTemp; if (!expr1) goto LabelTemp; push true(); goto LabelSkip; LabelTemp: push false(); LabelSkip:

Generate code for for QilNodeType.Attribute.

Generate code for QilNodeType.AttributeCtor.

Generate code for QilNodeType.Average.

Generate code for QilNodeType.VisitBefore.

VisitChildren should never be called.

Generate code for QilNodeType.Choice.

Generate code for QilNodeType.CommentCtor.

Generate code for QilNodeType.Conditional.

Generate code for for QilNodeType.Content.

Generate code for QilNodeType.DataSource.

Generates code to retrieve a document using the XmlResolver.

Generate code for for QilNodeType.Deref.

Find physical query plan for QilNodeType.Descendant.

Generate code for for QilNodeType.DescendantOrSelf.

Generate code for QilNodeType.Difference.

Generate code for QilNodeType.Divide.

Generate code for for QilNodeType.DocOrderDistinct.

Generate code for QilNodeType.DocumentCtor.

Generate code for QilNodeType.ElementCtor.

Generate code for QilNodeType.Eq.

Generate code for QilNodeType.Error.

Generate code for QilNodeType.False.

BranchingContext.OnFalse context: goto LabelParent; BranchingContext.OnTrue context: [nothing] BranchingContext.None context: push false();

Generate code for a QilNodeType.Filter.

Find physical query plan for QilNodeType.FollowingSibling.

Generate code for a QilNodeType.For.

Generate code for QilNodeType.Ne.

Generate code for QilNodeType.Gt.

Generate code for QilNodeType.Intersection.

Generate code for for QilNodeType.Invoke.

Generate code for QilNodeType.VisitIs.

Generate code for QilNodeType.IsEmpty.

BranchingContext.OnFalse context: is-empty(expr) ==> foreach (item in expr) goto LabelBranch; BranchingContext.OnTrue context: is-empty(expr) ==> foreach (item in expr) break; ... LabelOnEnd: (called if foreach is empty) goto LabelBranch; BranchingContext.None context: is-empty(expr) ==> foreach (item in expr) break; push true(); ... LabelOnEnd: (called if foreach is empty) push false();

Generate code for QilNodeType.IsType.

Generate code for QilNodeType.Le.

Generate code for QilNodeType.Length.

int length = 0; foreach (item in expr) length++;

Generate code for a QilNodeType.Let.

Generate code for QilNodeType.LiteralDecimal.

Generate code for QilNodeType.LiteralDouble.

Generate code for QilNodeType.LiteralInt32.

Generate code for QilNodeType.LiteralInt64.

Generate code for QilNodeType.LiteralQName.

Generate code for QilNodeType.LiteralString.

Generate code for QilNodeType.LocalNameOf.

Generate code for a QilNodeType.Loop.

Generate code for QilNodeType.Lt.

Generate code for QilNodeType.Maximum.

Generate code for QilNodeType.Minimum.

Generate code for QilNodeType.Modulo.

Generate code for QilNodeType.Multiply.

Generate code for QilNodeType.NameOf.

Generate code for QilNodeType.NamespaceDecl.

Generate code for QilNodeType.NamespaceUriOf.

Generate code for QilNodeType.Ne.

Generate code for QilNodeType.Negate.

Find physical query plan for QilNodeType.NodeRange.

Generate code for QilNodeType.Nop.

Generate code for QilNodeType.Not.

BranchingContext.OnFalse context: not(expr1) ==> if (expr1) goto LabelParent; BranchingContext.OnTrue context: not(expr1) ==> if (!expr1) goto LabelParent; BranchingContext.None context: not(expr1) ==> if (expr1) goto LabelTemp; push false(); goto LabelSkip; LabelTemp: push true(); LabelSkip:

Generate code for QilNodeType.OptimizeBarrier.

Generate code for QilNodeType.Or.

BranchingContext.OnFalse context: (expr1) or (expr2) ==> if (expr1) goto LabelTemp; if (!expr2) goto LabelParent; LabelTemp: BranchingContext.OnTrue context: (expr1) or (expr2) ==> if (expr1) goto LabelParent; if (expr1) goto LabelParent; BranchingContext.None context: (expr1) or (expr2) ==> if (expr1) goto LabelTemp; if (expr1) goto LabelTemp; push false(); goto LabelSkip; LabelTemp: push true(); LabelSkip:

Generate code for QilNodeType.PICtor.

Generate code for a QilNodeType.Parameter.

Generate code for for QilNodeType.Parent.

Generate code for QilNodeType.PositionOf.

Find physical query plan for QilNodeType.Preceding.

Find physical query plan for QilNodeType.PrecedingSibling.

Generate code for QilNodeType.PrefixOf.

Generate code for QilNodeType.RawTextCtor.

Generate code for for QilNodeType.Root.

Generate code for for QilNodeType.RtfCtor.

Find physical query plan for QilNodeType.Sequence.

Generate code for QilNodeType.Sort.

Generate code for QilNodeType.StrConcat.

Generate code for QilNodeType.StrLength.

Generate code for QilNodeType.StrParseQName.

Generate code for QilNodeType.Subtract.

Generate code for QilNodeType.Sum.

Generate code for QilNodeType.TextCtor.

Generate code for QilNodeType.True.

BranchingContext.OnFalse context: [nothing] BranchingContext.OnTrue context: goto LabelParent; BranchingContext.None context: push true();

Find physical query plan for QilNodeType.TypeAssert.

Generate code for QilNodeType.Union.

Generate code for QilNodeType.Warning.

Find physical query plan for QilNodeType.XPathFollowing.

Find physical query plan for QilNodeType.XPathNamespace.

Generate code for QilNodeType.XPathNodeValue.

Find physical query plan for QilNodeType.XPathPreceding.

Generate code for QilNodeType.XmlContext.

Generates code to retrieve the default document using the XmlResolver.

Generate code for QilNodeType.XsltConvert.

Generate code for QilNodeType.XsltCopy.

Generate code for QilNodeType.XsltCopyOf.

Generate code for QilNodeType.XsltGenerateId.

Generate code for for QilNodeType.XsltInvokeEarlyBound.

Generate code for for QilNodeType.XsltInvokeLateBound.

This method is called after calling any WriteEnd??? method. It generates code to perform runtime construction checks separately. This should only be called if the XmlQueryOutput::EndElementChk method will *not* be called.

Generate code for two-argument arithmetic operations.

This method is called before calling any WriteEnd??? method. It generates code to perform runtime construction checks separately. This should only be called if the XmlQueryOutput::StartElementChk method will *not* be called.

Returns true if the specified QilExpression node type is *guaranteed* to cache its results in an XmlQuerySequence, where items in the cache are stored using the default storage type.

Return true if a runtime check needs to be made in order to transition into the EnumAttrs state.

Return true if a runtime check needs to be made in order to transition into the WithinContent state.

For QilExpression types that map directly to CLR primitive types, the built-in CLR comparison operators can be used to perform the specified relational operation.

Generate code for comparison operations.

Generate code for QilNodeType.VisitBefore and QilNodeType.VisitAfter.

Generate code for one of the branches of QilNodeType.Conditional.

Iterate over items produced by the "nd" expression and copy each item to output.

Generate code for QilNodeType.Sum, QilNodeType.Average, QilNodeType.Minimum, and QilNodeType.Maximum.

Generate boiler-plate code to create an Xml iterator that controls a nested iterator.

Iterator iter; iter.Create(filter [, orSelf]); ...nested iterator... navInput = nestedNested; goto LabelCall; LabelNext: navInput = null; LabelCall: switch (iter.MoveNext(navInput)) { case IteratorState.NoMoreNodes: goto LabelNextCtxt; case IteratorState.NextInputNode: goto LabelNextNested; }

Generate boiler-plate code to create an Xml iterator that uses an XmlNavigatorFilter to filter items.

Iterator iter; iter.Create(navCtxt, filter [, orSelf] [, navEnd]); LabelNext: if (!iter.MoveNext()) goto LabelNextCtxt;

Generate code to combine nodes from two nested iterators using Union, Intersection, or Difference semantics.

Generate boiler-plate code to create a simple Xml iterator.

Iterator iter; iter.Create(navCtxt); LabelNext: if (!iter.MoveNext()) goto LabelNextCtxt;

Returns true if the specified element should cache attributes.

Mark iterator variables as out-of-scope.

Anchor any remaining labels.

End construction of the current iterator.

Construction within a loop is ending. If transition from non-Any to Any state occurs, then ensure that runtime state will be set.

Generate code for the specified function.

Generate code to concatenate string values returned by expression "ndStr" using the StringConcat helper class.

Generate boiler-plate code that calls MoveNext on an Xml iterator that controls a nested iterator. Iterator should have already been created by calling code.

... goto LabelCall; LabelNext: navCtxt = null; LabelCall: switch (iter.MoveNext(navCtxt)) { case IteratorState.NoMoreNodes: goto LabelNextCtxt; case IteratorState.NextInputNode: goto LabelNextNested; }

Generate boiler-plate code that calls MoveNext on a simple Xml iterator. Iterator should have already been created by calling code.

... LabelNext: if (!iter.MoveNext()) goto LabelNextCtxt;

Shortcut call to XmlILTypeHelper.GetStorageType, using an expression's prime type.

Shortcut call to XmlILTypeHelper.GetStorageType, using the prime type.

Shortcut call to XmlILTypeHelper.GetStorageType.

Shortcut call to XmlILTypeHelper.GetStorageType.

Get the XsltConvert method that converts from "typSrc" to "typDst". Return false if no such method exists. This conversion matrix should match the one in XsltConvert.ExternalValueToExternalValue.

There are a number of path patterns that can be rooted at DocOrderDistinct nodes. Determine whether one of these patterns has been previously matched on "ndDod". If so, generate code for the pattern and return true. Otherwise, just return false.

There are a number of path patterns that can be rooted at Filter nodes. Determine whether one of these patterns has been previously matched on "ndFilter". If so, generate code for the pattern and return true. Otherwise, just return false.

Return true if more than one node type is set.

Load XmlQueryOutput, load a name (computed or literal) and load an index to an Xml schema type. Return an enumeration that specifies what kind of name was loaded.

Load an XmlNavigatorFilter that matches only the specified name and types onto the stack.

Faster code can be generated if type test is just a node kind test. If this special case is detected, then generate code and return true. Otherwise, return false, and a call to MatchesXmlType will be generated instead.

Returns true if the specified node's owner element might have local namespaces added to it after attributes have already been added.

Generate code to cache a sequence of items that are pushed to output.

Calls NestedVisit(QilNode, Type, bool), storing result in the default storage type for "nd".

Recursively generate code to iterate over the results of the "nd" expression. When the expression has been fully iterated, it will jump to "lblOnEnd".

Recursively generate code to iterate over the results of the "nd" expression. If "nd" is pushed to the writer, then there are no results. If "nd" is a singleton expression and isCached is false, then generate code to construct the singleton. Otherwise, cache the sequence in an XmlQuerySequence object. Ensure that all items are converted to the specified "itemStorageType".

Generate code for the QilExpression node and ensure that results are fully cached as an XmlQuerySequence. All results should be converted to "itemStorageType" before being added to the cache.

Call NestedVisit(QilNode) and ensure that result is stored in local variable "loc".

Call NestedVisit(QilNode) and ensure that result is pushed onto the IL stack.

Generate code for both QilExpression nodes and ensure that each result is pushed onto the IL stack.

Call NestedVisit(QilNode, Type, bool) and ensure that result is pushed onto the IL stack.

Start a nested iterator in a branching context and recursively generate code for the specified QilExpression node.

Create IteratorDescriptor for each global value. This pre-visit is necessary because a global early in the list may reference a global later in the list and therefore expect its IteratorDescriptor to already be initialized.

Map a QilExpression constructor type into the XPathNodeType enumeration.

Map the XmlNodeKindFlags enumeration into the XPathNodeType enumeration.

Generate code for QilNodeType.Sequence, when sort-merging to retain document order is not necessary.

Generate code for a Let, For, or Parameter iterator. Bind iterated value to a variable.

Fixup branching context for all but the last test in a conjunctive (Logical And) expression. Return a temporary label which will be passed to StartLastAndBranch() and EndAndBranch().

Bind values produced by the "ndFor" expression to a non-stack location that can later be referenced.

Fixup branching context for the last test in a conjunctive (Logical And) expression.

Start construction of a new nested iterator. If this.iterCurr == null, then the new iterator is a top-level, or root iterator. Otherwise, the new iterator will be nested within the current iterator.

Calls StartNestedIterator(nd) and also sets up the nested iterator to branch to "lblOnEnd" when iteration is complete.

Construction within a loop is starting. If transition from non-Any to Any state occurs, then ensure that runtime state will be set.

Ensure that the "locNav" navigator is positioned to the context node "ndCtxt".

If the comparison involves a qname, then perform comparison using atoms and return true. Otherwise, return false (caller will perform comparison).

If the first argument is a constant value that evaluates to zero, then a more optimal instruction sequence can be generated that does not have to push the zero onto the stack. Instead, a Brfalse or Brtrue instruction can be used.

Generate code for the empty sequence.

Visit each global variable or parameter. Create a IteratorDescriptor for each global value. Generate code for default values.

Generate code to push the local name, namespace uri, or qname of the context navigator.

Generate code to add a (value, collation) sort key to the XmlSortKeyAccumulator.

Generate code for QilNodeType.StrParseQName.

Generate code for QilNodeType.TextCtor and QilNodeType.RawTextCtor.

Generate code to compare the top stack value to 0 by using the Brfalse or Brtrue instructions, which avoid pushing zero onto the stack. Both of these instructions test for null/zero/false.