C# ProcessingContext.CreateSequence方法代码示例

 internal override Opcode Eval(ProcessingContext context)
 {
     if (!context.LoadVariable(this.expr.Variable))
     {
         context.PushSequenceFrame();
         NodeSequence seq = context.CreateSequence();
         seq.Add(context.Processor.ContextNode);
         context.PushSequence(seq);
         int counterMarker = context.Processor.CounterMarker;
         try
         {
             this.expr.Eval(context);
         }
         catch (XPathNavigatorException exception)
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exception.Process(this));
         }
         catch (NavigatorInvalidBodyAccessException exception2)
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exception2.Process(this));
         }
         context.Processor.CounterMarker = counterMarker;
         context.PopSequenceFrame();
         context.PopSequenceFrame();
         context.LoadVariable(this.expr.Variable);
     }
     return base.next;
 }

 internal override void InvokeInternal(ProcessingContext context, int argCount)
 {
     StackFrame topArg = context.TopArg;
     SeekableXPathNavigator contextNode = context.Processor.ContextNode;
     long currentPosition = contextNode.CurrentPosition;
     while (topArg.basePtr <= topArg.endPtr)
     {
         string str = context.PeekString(topArg.basePtr);
         NodeSequence val = context.CreateSequence();
         if (XPathMessageFunction.MoveToHeader(contextNode) && contextNode.MoveToFirstChild())
         {
             do
             {
                 long num2 = contextNode.CurrentPosition;
                 string str2 = XPathMessageFunctionActor.ExtractFromNavigator(contextNode);
                 contextNode.CurrentPosition = num2;
                 if (str2 == str)
                 {
                     val.Add(contextNode);
                 }
             }
             while (contextNode.MoveToNext());
         }
         context.SetValue(context, topArg.basePtr, val);
         topArg.basePtr++;
     }
     contextNode.CurrentPosition = currentPosition;
 }

 internal override void InvokeInternal(ProcessingContext context, int argCount)
 {
     int iterationCount = context.IterationCount;
     context.PushSequenceFrame();
     if (iterationCount > 0)
     {
         NodeSequence seq = context.CreateSequence();
         seq.StartNodeset();
         SeekableXPathNavigator contextNode = context.Processor.ContextNode;
         long currentPosition = contextNode.CurrentPosition;
         if (XPathMessageFunction.MoveToAddressingHeader(contextNode, "RelatesTo"))
         {
             seq.Add(contextNode);
             while (XPathMessageFunction.MoveToAddressingHeaderSibling(contextNode, "RelatesTo"))
             {
                 seq.Add(contextNode);
             }
         }
         seq.StopNodeset();
         context.PushSequence(seq);
         for (int i = 1; i < iterationCount; i++)
         {
             seq.refCount++;
             context.PushSequence(seq);
         }
         contextNode.CurrentPosition = currentPosition;
     }
 }

 internal override Opcode Eval(ProcessingContext context)
 {
     StackFrame topSequenceArg = context.TopSequenceArg;
     Value[] sequences = context.Sequences;
     bool sequenceStackInUse = context.SequenceStackInUse;
     context.PushSequenceFrame();
     for (int i = topSequenceArg.basePtr; i <= topSequenceArg.endPtr; i++)
     {
         NodeSequence sequence = sequences[i].Sequence;
         if (sequence.Count == 0)
         {
             if (!sequenceStackInUse)
             {
                 context.PushSequence(NodeSequence.Empty);
             }
         }
         else
         {
             NodeSequenceItem[] items = sequence.Items;
             for (int j = 0; j < sequence.Count; j++)
             {
                 SeekableXPathNavigator contextNode = items[j].GetNavigator();
                 NodeSequence destSequence = context.CreateSequence();
                 destSequence.StartNodeset();
                 base.criteria.Select(contextNode, destSequence);
                 destSequence.StopNodeset();
                 context.PushSequence(destSequence);
             }
         }
     }
     return base.next;
 }

        internal override Opcode Eval(ProcessingContext context)
        {
            context.PushContextSequenceFrame();
            NodeSequence seq = context.CreateSequence();

            seq.StartNodeset();
            seq.Add(context.Processor.ContextNode);
            seq.StopNodeset();

            context.PushSequence(seq);

            return this.next;
        }

 internal override Opcode Eval(ProcessingContext context)
 {
     StackFrame topSequenceArg = context.TopSequenceArg;
     SeekableXPathNavigator contextNode = null;
     Value[] sequences = context.Sequences;
     for (int i = topSequenceArg.basePtr; i <= topSequenceArg.endPtr; i++)
     {
         NodeSequence sequence = sequences[i].Sequence;
         int count = sequence.Count;
         if (count == 0)
         {
             context.ReplaceSequenceAt(i, NodeSequence.Empty);
             context.ReleaseSequence(sequence);
         }
         else
         {
             NodeSequenceItem[] items = sequence.Items;
             if (sequence.CanReuse(context))
             {
                 contextNode = items[0].GetNavigator();
                 sequence.Clear();
                 sequence.StartNodeset();
                 this.criteria.Select(contextNode, sequence);
                 sequence.StopNodeset();
             }
             else
             {
                 NodeSequence destSequence = null;
                 for (int j = 0; j < count; j++)
                 {
                     contextNode = items[j].GetNavigator();
                     if (destSequence == null)
                     {
                         destSequence = context.CreateSequence();
                     }
                     destSequence.StartNodeset();
                     this.criteria.Select(contextNode, destSequence);
                     destSequence.StopNodeset();
                 }
                 context.ReplaceSequenceAt(i, (destSequence != null) ? destSequence : NodeSequence.Empty);
                 context.ReleaseSequence(sequence);
             }
         }
     }
     return base.next;
 }

 internal override Opcode Eval(ProcessingContext context)
 {
     Value[] values = context.Values;
     StackFrame topArg = context.TopArg;
     for (int i = topArg.basePtr; i <= topArg.endPtr; i++)
     {
         NodeSequence sequence = values[i].Sequence;
         NodeSequence val = context.CreateSequence();
         for (int j = 0; j < sequence.Count; j++)
         {
             NodeSequenceItem item = sequence[j];
             val.AddCopy(ref item);
         }
         val.Merge();
         context.SetValue(context, i, val);
     }
     return base.next;
 }

 internal override Opcode Eval(ProcessingContext context)
 {
     int iterationCount = context.IterationCount;
     Opcode next = base.next;
     context.PushSequenceFrame();
     NodeSequence empty = context.CreateSequence();
     if ((base.next != null) && ((base.next.Flags & OpcodeFlags.CompressableSelect) != OpcodeFlags.None))
     {
         SeekableXPathNavigator contextNode = context.Processor.ContextNode;
         contextNode.MoveToRoot();
         next = base.next.Eval(empty, contextNode);
         while ((next != null) && ((next.Flags & OpcodeFlags.CompressableSelect) != OpcodeFlags.None))
         {
             next = next.Next;
         }
     }
     else
     {
         empty.StartNodeset();
         SeekableXPathNavigator node = context.Processor.ContextNode;
         node.MoveToRoot();
         empty.Add(node);
         empty.StopNodeset();
     }
     if (empty.Count == 0)
     {
         context.ReleaseSequence(empty);
         empty = NodeSequence.Empty;
     }
     for (int i = 0; i < iterationCount; i++)
     {
         context.PushSequence(empty);
     }
     if (iterationCount > 1)
     {
         empty.refCount += iterationCount - 1;
     }
     return next;
 }

 internal override Opcode Eval(ProcessingContext context)
 {
     StackFrame topSequenceArg = context.TopSequenceArg;
     Value[] values = context.Values;
     StackFrame topArg = context.TopArg;
     Value[] sequences = context.Sequences;
     context.PushSequenceFrame();
     for (int i = topSequenceArg.basePtr; i <= topSequenceArg.endPtr; i++)
     {
         NodeSequence sequence = sequences[i].Sequence;
         if (sequence.Count > 0)
         {
             NodeSequenceItem[] items = sequence.Items;
             NodeSequence sequence2 = null;
             int basePtr = topArg.basePtr;
             for (int j = 0; basePtr <= topArg.endPtr; j++)
             {
                 if (this.test == values[basePtr].Boolean)
                 {
                     if (sequence2 == null)
                     {
                         sequence2 = context.CreateSequence();
                     }
                     sequence2.AddCopy(ref items[j], NodeSequence.GetContextSize(sequence, j));
                 }
                 else if (items[j].Last && (sequence2 != null))
                 {
                     sequence2.Items[sequence2.Count - 1].Last = true;
                 }
                 basePtr++;
             }
             context.PushSequence((sequence2 == null) ? NodeSequence.Empty : sequence2);
             sequence2 = null;
         }
     }
     return base.next;
 }

 internal NodeSequence Union(ProcessingContext context, NodeSequence otherSeq)
 {
     NodeSequence sequence = context.CreateSequence();
     SortedBuffer<QueryNode, QueryNodeComparer> buffer = new SortedBuffer<QueryNode, QueryNodeComparer>(staticQueryNodeComparerInstance);
     for (int i = 0; i < this.count; i++)
     {
         buffer.Add(this.items[i].Node);
     }
     for (int j = 0; j < otherSeq.count; j++)
     {
         buffer.Add(otherSeq.items[j].Node);
     }
     for (int k = 0; k < buffer.Count; k++)
     {
         sequence.Add(buffer[k]);
     }
     sequence.RenumberItems();
     return sequence;
 }

        internal override Opcode Eval(ProcessingContext context)
        {
            XPathNavigator nav = context.Processor.ContextNode;
            if (nav != null && context.Processor.ContextMessage != null)
            {
                ((SeekableMessageNavigator)nav).Atomize();
            }

            if (this.argCount == 0)
            {
                context.PushFrame();
                int count = context.IterationCount;
                if (count > 0)
                {
                    object ret = this.function.Invoke(this.xsltContext, NullArgs, nav);
                    switch (this.function.ReturnType)
                    {
                        case XPathResultType.String:
                            context.Push((string)ret, count);
                            break;

                        case XPathResultType.Number:
                            context.Push((double)ret, count);
                            break;

                        case XPathResultType.Boolean:
                            context.Push((bool)ret, count);
                            break;

                        case XPathResultType.NodeSet:
                            NodeSequence seq = context.CreateSequence();
                            XPathNodeIterator iter = (XPathNodeIterator)ret;
                            seq.Add(iter);
                            context.Push(seq, count);
                            break;

                        default:
                            // This should never be reached
                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.Unexpected, SR.GetString(SR.QueryFunctionTypeNotSupported, this.function.ReturnType.ToString())));
                    }
                }
            }
            else
            {
                // PERF, [....], see if we can cache these arrays to avoid allocations
                object[] xsltArgs = new object[this.argCount];
                int iterationCount = context.TopArg.Count;
                for (int iteration = 0; iteration < iterationCount; ++iteration)
                {
                    for (int i = 0; i < this.argCount; ++i)
                    {
                        StackFrame arg = context[i];
                        Fx.Assert(iteration < arg.Count, "");

                        switch (this.function.ArgTypes[i])
                        {
                            case XPathResultType.String:
                                xsltArgs[i] = context.PeekString(arg[iteration]);
                                break;

                            case XPathResultType.Number:
                                xsltArgs[i] = context.PeekDouble(arg[iteration]);
                                break;

                            case XPathResultType.Boolean:
                                xsltArgs[i] = context.PeekBoolean(arg[iteration]);
                                break;

                            case XPathResultType.NodeSet:
                                NodeSequenceIterator iter = new NodeSequenceIterator(context.PeekSequence(arg[iteration]));
                                xsltArgs[i] = iter;
                                this.iterList.Add(iter);
                                break;

                            default:
                                // This should never be reached
                                throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.Unexpected, SR.GetString(SR.QueryFunctionTypeNotSupported, this.function.ArgTypes[i].ToString())));
                        }
                    }

                    object ret = this.function.Invoke(this.xsltContext, xsltArgs, nav);

                    if (this.iterList != null)
                    {
                        for (int i = 0; i < this.iterList.Count; ++i)
                        {
                            this.iterList[i].Clear();
                        }
                        this.iterList.Clear();
                    }

                    switch (this.function.ReturnType)
                    {
                        case XPathResultType.String:
                            context.SetValue(context, context[this.argCount - 1][iteration], (string)ret);
                            break;

                        case XPathResultType.Number:
                            context.SetValue(context, context[this.argCount - 1][iteration], (double)ret);
                            break;
//.........这里部分代码省略.........

        internal override Opcode Eval(ProcessingContext context)
        {
            StackFrame topFrame = context.TopSequenceArg;
            Value[] sequences = context.Sequences;

            bool wasInUse = context.SequenceStackInUse;
            context.PushSequenceFrame();
            for (int i = topFrame.basePtr; i <= topFrame.endPtr; ++i)
            {
                NodeSequence sourceSeq = sequences[i].Sequence;
                int count = sourceSeq.Count;
                if (count == 0)
                {
                    // Empty sequence. 
                    // Since there are no nodes in the sequence, we will track this sequence also 
                    // using an empty sequence 
                    if (!wasInUse)
                        context.PushSequence(NodeSequence.Empty);
                }
                else
                {
                    NodeSequenceItem[] items = sourceSeq.Items;
                    for (int item = 0; item < sourceSeq.Count; ++item)
                    {
                        SeekableXPathNavigator node = items[item].GetNavigator();
                        Fx.Assert(null != node, "");

                        NodeSequence newSeq = context.CreateSequence();
                        newSeq.StartNodeset();

                        this.criteria.Select(node, newSeq);

                        newSeq.StopNodeset();

                        context.PushSequence(newSeq);
                    }
                }
            }
            return this.next;
        }

        internal override void InvokeInternal(ProcessingContext context, int argCount)
        {
            StackFrame actorArg = context.TopArg;

            SeekableXPathNavigator nav = context.Processor.ContextNode;
            long p = nav.CurrentPosition;
            while (actorArg.basePtr <= actorArg.endPtr)
            {
                string actor = context.PeekString(actorArg.basePtr);
                NodeSequence seq = context.CreateSequence();

                if (MoveToHeader(nav) && nav.MoveToFirstChild())
                {
                    do
                    {
                        // PERF, [....], this will be faster if I cache the envelope namespace to do the
                        //               actor lookup by hand
                        long pos = nav.CurrentPosition;
                        string navActor = XPathMessageFunctionActor.ExtractFromNavigator(nav);
                        nav.CurrentPosition = pos;

                        if (navActor == actor)
                        {
                            seq.Add(nav);
                        }
                    } while (nav.MoveToNext());
                }

                context.SetValue(context, actorArg.basePtr, seq);

                actorArg.basePtr++;
            }
            nav.CurrentPosition = p;
        }

 internal static void IterateAndPushSequences(ProcessingContext context)
 {
     StackFrame topSequenceArg = context.TopSequenceArg;
     Value[] sequences = context.Sequences;
     context.PushFrame();
     while (topSequenceArg.basePtr <= topSequenceArg.endPtr)
     {
         NodeSequence sequence = sequences[topSequenceArg.basePtr++].Sequence;
         if (sequence.Count == 0)
         {
             context.PushSequence(NodeSequence.Empty);
         }
         else
         {
             for (int i = 0; i < sequence.Count; i++)
             {
                 NodeSequence sequence2 = context.CreateSequence();
                 sequence2.StartNodeset();
                 sequence2.Add(ref sequence.Items[i]);
                 sequence2.StopNodeset();
                 context.Push(sequence2);
             }
         }
     }
 }

 internal override void EvalSpecial(ProcessingContext context)
 {
     int counterMarker = context.Processor.CounterMarker;
     if (!context.LoadVariable(base.var))
     {
         XPathMessageContext.HeaderFun.InvokeInternal(context, 0);
         context.SaveVariable(base.var, context.Processor.ElapsedCount(counterMarker));
     }
     NodeSequence[] sequenceArray = new NodeSequence[base.children.Count];
     NodeSequence sequence = context.Sequences[context.TopSequenceArg.basePtr].Sequence;
     for (int i = 0; i < base.children.Count; i++)
     {
         sequenceArray[i] = context.CreateSequence();
         sequenceArray[i].StartNodeset();
     }
     SeekableXPathNavigator node = sequence[0].GetNavigator();
     if (node.MoveToFirstChild())
     {
         do
         {
             if (node.NodeType == XPathNodeType.Element)
             {
                 List<SubExpr> list;
                 Dictionary<string, List<SubExpr>> dictionary;
                 string localName = node.LocalName;
                 string namespaceURI = node.NamespaceURI;
                 if (this.nameLookup.TryGetValue(namespaceURI, out dictionary))
                 {
                     if (dictionary.TryGetValue(localName, out list))
                     {
                         for (int k = 0; k < list.Count; k++)
                         {
                             sequenceArray[this.indexLookup[list[k]].i].Add(node);
                         }
                     }
                     if (dictionary.TryGetValue(QueryDataModel.Wildcard, out list))
                     {
                         for (int m = 0; m < list.Count; m++)
                         {
                             sequenceArray[this.indexLookup[list[m]].i].Add(node);
                         }
                     }
                 }
                 if (this.nameLookup.TryGetValue(QueryDataModel.Wildcard, out dictionary) && dictionary.TryGetValue(QueryDataModel.Wildcard, out list))
                 {
                     for (int n = 0; n < list.Count; n++)
                     {
                         sequenceArray[this.indexLookup[list[n]].i].Add(node);
                     }
                 }
             }
         }
         while (node.MoveToNext());
     }
     int num6 = context.Processor.CounterMarker;
     for (int j = 0; j < base.children.Count; j++)
     {
         if (base.children[j].useSpecial)
         {
             sequenceArray[j].StopNodeset();
             context.Processor.CounterMarker = num6;
             context.PushSequenceFrame();
             context.PushSequence(sequenceArray[j]);
             for (Opcode opcode = base.children[j].FirstOp.Next; opcode != null; opcode = opcode.Eval(context))
             {
             }
             context.SaveVariable(base.children[j].var, context.Processor.ElapsedCount(counterMarker));
             context.PopSequenceFrame();
         }
         else
         {
             context.ReleaseSequence(sequenceArray[j]);
         }
     }
     context.Processor.CounterMarker = counterMarker;
 }