Files
mono/mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Dispatcher/QueryOpcode.cs
T
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

528 lines
13 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Dispatcher
{
using System.Collections.Generic;
using System.Runtime;
using System.Threading;
enum OpcodeID
{
NoOp,
SubExpr,
// Flow opcodes
Branch,
JumpIfNot,
Filter,
Function,
XsltFunction,
XsltInternalFunction,
Cast,
QueryTree,
BlockEnd,
SubRoutine,
// Set Opcodes
Ordinal,
LiteralOrdinal,
Empty,
Union,
Merge,
// Boolean opcodes
ApplyBoolean,
StartBoolean,
EndBoolean,
// Relational opcodes
Relation,
StringEquals,
NumberEquals,
StringEqualsBranch,
NumberEqualsBranch,
NumberRelation,
NumberInterval,
NumberIntervalBranch,
// Select/Node Operators
Select,
InitialSelect,
SelectRoot,
// Stack operators
PushXsltVariable,
PushBool,
PushString,
PushDouble,
PushContextNode,
PushNodeSequence,
PushPosition,
PopSequenceToValueStack,
PopSequenceToSequenceStack,
PopContextNodes,
PushContextCopy,
PopValueFrame,
// Math opcode
Plus,
Minus,
Multiply,
Divide,
Mod,
Negate,
// Specialized String operators
StringPrefix,
StringPrefixBranch,
// Results
MatchAlways,
MatchResult,
MatchFilterResult,
MatchMultipleResult,
MatchSingleFx,
QuerySingleFx,
QueryResult,
QueryMultipleResult
}
enum OpcodeFlags
{
None = 0x00000000,
Single = 0x00000001,
Multiple = 0x00000002,
Branch = 0x00000004,
Result = 0x00000008,
Jump = 0x00000010,
Literal = 0x00000020,
Select = 0x00000040,
Deleted = 0x00000080,
InConditional = 0x00000100,
NoContextCopy = 0x00000200,
InitialSelect = 0x00000400,
CompressableSelect = 0x00000800,
Fx = 0x00001000
}
abstract class Opcode
{
protected OpcodeFlags flags;
protected Opcode next;
OpcodeID opcodeID;
protected Opcode prev;
#if DEBUG
// debugging aid. Because C# references do not have displayble numeric values, hard to deduce the
// graph structure to see what opcode is connected to what
static long nextUniqueId = 0;
internal long uniqueID;
#endif
internal Opcode(OpcodeID id)
{
this.opcodeID = id;
this.flags = OpcodeFlags.Single;
#if DEBUG
this.uniqueID = Opcode.NextUniqueId();
#endif
}
internal OpcodeFlags Flags
{
get
{
return this.flags;
}
set
{
this.flags = value;
}
}
internal OpcodeID ID
{
get
{
return this.opcodeID;
}
}
internal Opcode Next
{
get
{
return this.next;
}
set
{
this.next = value;
}
}
internal Opcode Prev
{
get
{
return this.prev;
}
set
{
this.prev = value;
}
}
#if DEBUG
static long NextUniqueId()
{
return Interlocked.Increment(ref Opcode.nextUniqueId);
}
#endif
internal virtual void Add(Opcode op)
{
Fx.Assert(null != op, "");
Fx.Assert(null != this.prev, "");
// Create a branch that will include both this and the new opcode
this.prev.AddBranch(op);
}
internal virtual void AddBranch(Opcode opcode)
{
Fx.Assert(null != opcode, "");
// Replace what follows this opcode with a branch containing .next and the new opcode
// If this opcode is a conditional, then since the tree structure is about to change, conditional
// reachability for everything that follows is about to change.
// 1. Remove .next from the conditional's AlwaysBranch Table.
// 2. Create the new branch structure.
// 3. The branch, once in the tree, will fix up all conditional jumps
Opcode next = this.next;
if (this.TestFlag(OpcodeFlags.InConditional))
{
this.DelinkFromConditional(next);
}
BranchOpcode branch = new BranchOpcode();
this.next = null;
this.Attach(branch);
if (null != next)
{
Fx.Assert(OpcodeID.Branch != next.ID, "");
branch.Add(next);
}
branch.Add(opcode);
}
internal void Attach(Opcode op)
{
Fx.Assert(null == this.next, "");
this.next = op;
op.prev = this;
}
internal virtual void CollectXPathFilters(ICollection<MessageFilter> filters)
{
if (this.next != null)
{
this.next.CollectXPathFilters(filters);
}
}
internal virtual bool IsEquivalentForAdd(Opcode opcode)
{
return (this.ID == opcode.ID);
}
internal bool IsMultipleResult()
{
return ((this.flags & (OpcodeFlags.Result | OpcodeFlags.Multiple)) ==
(OpcodeFlags.Result | OpcodeFlags.Multiple));
}
internal virtual void DelinkFromConditional(Opcode child)
{
Fx.Assert(this.TestFlag(OpcodeFlags.InConditional), "");
if (this.TestFlag(OpcodeFlags.InConditional))
{
((QueryConditionalBranchOpcode)this.prev).RemoveAlwaysBranch(child);
}
}
internal Opcode DetachChild()
{
Opcode child = this.next;
if (child != null)
{
if (this.IsInConditional())
{
this.DelinkFromConditional(child);
}
}
this.next = null;
child.prev = null;
return child;
}
internal void DetachFromParent()
{
Opcode parent = this.prev;
if (parent != null)
{
parent.DetachChild();
}
}
internal virtual bool Equals(Opcode op)
{
return (op.ID == this.ID);
}
internal virtual Opcode Eval(ProcessingContext context)
{
return this.next;
}
internal virtual Opcode Eval(NodeSequence sequence, SeekableXPathNavigator node)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.Unexpected));
}
internal virtual Opcode EvalSpecial(ProcessingContext context)
{
return this.Eval(context);
}
internal virtual bool IsInConditional()
{
return this.TestFlag(OpcodeFlags.InConditional);
}
internal bool IsReachableFromConditional()
{
return (null != this.prev && this.prev.IsInConditional());
}
internal virtual Opcode Locate(Opcode opcode)
{
Fx.Assert(null != opcode, "");
if (null != this.next && this.next.Equals(opcode))
{
return this.next;
}
return null;
}
internal virtual void LinkToConditional(Opcode child)
{
Fx.Assert(this.TestFlag(OpcodeFlags.InConditional), "");
if (this.TestFlag(OpcodeFlags.InConditional))
{
((QueryConditionalBranchOpcode)this.prev).AddAlwaysBranch(this, child);
}
}
internal virtual void Remove()
{
if (null == this.next)
{
Opcode prevOpcode = this.prev;
if (null != prevOpcode)
{
prevOpcode.RemoveChild(this);
prevOpcode.Remove();
}
}
}
internal virtual void RemoveChild(Opcode opcode)
{
Fx.Assert(null != opcode, "");
Fx.Assert(this.next == opcode, "");
if (this.IsInConditional())
{
this.DelinkFromConditional(opcode);
}
opcode.prev = null;
this.next = null;
opcode.Flags |= OpcodeFlags.Deleted;
}
internal virtual void Replace(Opcode replace, Opcode with)
{
Fx.Assert(null != replace && null != with, "");
if (this.next == replace)
{
bool isConditional = this.IsInConditional();
if (isConditional)
{
this.DelinkFromConditional(this.next);
}
this.next.prev = null;
this.next = with;
with.prev = this;
if (isConditional)
{
this.LinkToConditional(with);
}
}
}
internal bool TestFlag(OpcodeFlags flag)
{
return (0 != (this.flags & flag));
}
#if DEBUG_FILTER
public override string ToString()
{
#if DEBUG
return string.Format("{0}(#{1})", this.opcodeID.ToString(), this.uniqueID);
#else
return this.opcodeID.ToString();
#endif
}
#endif
internal virtual void Trim()
{
if (this.next != null)
{
this.next.Trim();
}
}
}
struct OpcodeBlock
{
Opcode first;
Opcode last;
internal OpcodeBlock(Opcode first)
{
this.first = first;
this.first.Prev = null;
for (this.last = this.first; this.last.Next != null; this.last = this.last.Next);
}
#if FILTEROPTIMIZER
internal OpcodeBlock(Opcode first, Opcode last)
{
this.first = first;
this.first.Prev = null;
this.last = last;
this.Last.Next = null;
}
#endif
internal Opcode First
{
get
{
return this.first;
}
}
internal Opcode Last
{
get
{
return this.last;
}
}
internal void Append(Opcode opcode)
{
Fx.Assert(null != opcode, "");
if (null == this.last)
{
this.first = opcode;
this.last = opcode;
}
else
{
this.last.Attach(opcode);
opcode.Next = null;
this.last = opcode;
}
}
internal void Append(OpcodeBlock block)
{
if (null == this.last)
{
this.first = block.first;
this.last = block.last;
}
else
{
this.last.Attach(block.first);
this.last = block.last;
}
}
internal void DetachLast()
{
if (null == this.last)
{
return;
}
Opcode newLast = this.last.Prev;
this.last.Prev = null;
this.last = newLast;
if (null != this.last)
{
this.last.Next = null;
}
}
}
class OpcodeList
{
QueryBuffer<Opcode> opcodes;
public OpcodeList(int capacity)
{
this.opcodes = new QueryBuffer<Opcode>(capacity);
}
public int Count
{
get
{
return this.opcodes.count;
}
}
public Opcode this[int index]
{
get
{
return this.opcodes[index];
}
set
{
this.opcodes[index] = value;
}
}
public void Add(Opcode opcode)
{
this.opcodes.Add(opcode);
}
public int IndexOf(Opcode opcode)
{
return this.opcodes.IndexOf(opcode);
}
public void Remove(Opcode opcode)
{
this.opcodes.Remove(opcode);
}
public void Trim()
{
this.opcodes.TrimToCount();
}
}
}