1610 lines
49 KiB
C#
1610 lines
49 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
namespace System.ServiceModel.Dispatcher
|
|
{
|
|
using System.Collections.Generic;
|
|
using System.Runtime;
|
|
|
|
abstract class JumpOpcode : Opcode
|
|
{
|
|
Opcode jump;
|
|
|
|
internal JumpOpcode(OpcodeID id, Opcode jump)
|
|
: base(id)
|
|
{
|
|
this.Jump = jump;
|
|
this.flags |= OpcodeFlags.Jump;
|
|
}
|
|
|
|
internal Opcode Jump
|
|
{
|
|
get
|
|
{
|
|
return this.jump;
|
|
}
|
|
set
|
|
{
|
|
Fx.Assert(value.ID == OpcodeID.BlockEnd, "");
|
|
this.AddJump((BlockEndOpcode)value);
|
|
}
|
|
}
|
|
|
|
internal void AddJump(BlockEndOpcode jumpTo)
|
|
{
|
|
bool conditional = this.IsReachableFromConditional();
|
|
if (conditional)
|
|
{
|
|
this.prev.DelinkFromConditional(this);
|
|
}
|
|
|
|
if (null == this.jump)
|
|
{
|
|
this.jump = jumpTo;
|
|
}
|
|
else
|
|
{
|
|
BranchOpcode jumpBranch;
|
|
if (this.jump.ID == OpcodeID.Branch)
|
|
{
|
|
// already a branch
|
|
jumpBranch = (BranchOpcode)this.jump;
|
|
}
|
|
else
|
|
{
|
|
BlockEndOpcode currentJump = (BlockEndOpcode)this.jump;
|
|
jumpBranch = new BranchOpcode();
|
|
jumpBranch.Branches.Add(currentJump);
|
|
this.jump = jumpBranch;
|
|
}
|
|
jumpBranch.Branches.Add(jumpTo);
|
|
}
|
|
jumpTo.LinkJump(this);
|
|
|
|
if (conditional && null != this.jump)
|
|
{
|
|
this.prev.LinkToConditional(this);
|
|
}
|
|
}
|
|
|
|
internal override void Remove()
|
|
{
|
|
if (null == this.jump)
|
|
{
|
|
base.Remove();
|
|
}
|
|
}
|
|
|
|
internal void RemoveJump(BlockEndOpcode jumpTo)
|
|
{
|
|
Fx.Assert(null != this.jump, "");
|
|
|
|
bool conditional = this.IsReachableFromConditional();
|
|
if (conditional)
|
|
{
|
|
this.prev.DelinkFromConditional(this);
|
|
}
|
|
|
|
if (this.jump.ID == OpcodeID.Branch)
|
|
{
|
|
BranchOpcode jumpBranch = (BranchOpcode)this.jump;
|
|
jumpTo.DeLinkJump(this);
|
|
jumpBranch.RemoveChild(jumpTo);
|
|
if (0 == jumpBranch.Branches.Count)
|
|
{
|
|
this.jump = null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Fx.Assert(object.ReferenceEquals(jumpTo, this.jump), "");
|
|
jumpTo.DeLinkJump(this);
|
|
this.jump = null;
|
|
}
|
|
|
|
if (conditional && null != this.jump)
|
|
{
|
|
this.prev.LinkToConditional(this);
|
|
}
|
|
}
|
|
|
|
internal override void Trim()
|
|
{
|
|
if (this.jump.ID == OpcodeID.Branch)
|
|
{
|
|
this.jump.Trim();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
class JumpIfOpcode : JumpOpcode
|
|
{
|
|
protected bool test;
|
|
|
|
internal JumpIfOpcode(Opcode jump, bool test)
|
|
: this(OpcodeID.JumpIfNot, jump, test)
|
|
{
|
|
}
|
|
|
|
protected JumpIfOpcode(OpcodeID id, Opcode jump, bool test)
|
|
: base(id, jump)
|
|
{
|
|
this.test = test;
|
|
}
|
|
|
|
internal bool Test
|
|
{
|
|
get
|
|
{
|
|
return this.test;
|
|
}
|
|
}
|
|
|
|
internal override bool Equals(Opcode op)
|
|
{
|
|
if (base.Equals(op))
|
|
{
|
|
return (this.test == ((JumpIfOpcode)op).test);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
internal override Opcode Eval(ProcessingContext context)
|
|
{
|
|
Fx.Assert(null != context, "");
|
|
|
|
StackFrame arg = context.TopArg;
|
|
for (int i = arg.basePtr; i <= arg.endPtr; ++i)
|
|
{
|
|
Fx.Assert(context.Values[i].IsType(ValueDataType.Boolean), "");
|
|
if (this.test == context.Values[i].Boolean)
|
|
{
|
|
// At least one result satisfies the test. Don't branch
|
|
return this.next;
|
|
}
|
|
}
|
|
|
|
// Jump, since no result is satisfactory..
|
|
return this.Jump;
|
|
}
|
|
|
|
#if DEBUG_FILTER
|
|
public override string ToString()
|
|
{
|
|
return string.Format("{0} {1}", base.ToString(), this.test);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
class ApplyBooleanOpcode : JumpIfOpcode
|
|
{
|
|
internal ApplyBooleanOpcode(Opcode jump, bool test)
|
|
: this(OpcodeID.ApplyBoolean, jump, test)
|
|
{
|
|
}
|
|
|
|
protected ApplyBooleanOpcode(OpcodeID id, Opcode jump, bool test)
|
|
: base(id, jump, test)
|
|
{
|
|
}
|
|
|
|
internal override Opcode Eval(ProcessingContext context)
|
|
{
|
|
int matchCount = this.UpdateResultMask(context);
|
|
context.PopFrame();
|
|
if (0 == matchCount)
|
|
{
|
|
return this.Jump;
|
|
}
|
|
|
|
return this.next;
|
|
}
|
|
|
|
protected int UpdateResultMask(ProcessingContext context)
|
|
{
|
|
StackFrame results = context.TopArg;
|
|
StackFrame resultMask = context.SecondArg;
|
|
Value[] values = context.Values;
|
|
int testCount = 0;
|
|
|
|
for (int maskIndex = resultMask.basePtr, resultIndex = results.basePtr; maskIndex <= resultMask.endPtr; ++maskIndex)
|
|
{
|
|
if (this.test == values[maskIndex].Boolean)
|
|
{
|
|
bool boolResult = values[resultIndex].Boolean;
|
|
if (this.test == boolResult)
|
|
{
|
|
testCount++;
|
|
}
|
|
values[maskIndex].Boolean = boolResult;
|
|
++resultIndex;
|
|
}
|
|
}
|
|
return testCount;
|
|
}
|
|
|
|
#if DEBUG_FILTER
|
|
public override string ToString()
|
|
{
|
|
return string.Format("{0} {1}", base.ToString(), this.test);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// 'And' booleans: test is true
|
|
// 'Or' booleans: test is false
|
|
class StartBooleanOpcode : Opcode
|
|
{
|
|
bool test;
|
|
|
|
internal StartBooleanOpcode(bool test)
|
|
: base(OpcodeID.StartBoolean)
|
|
{
|
|
this.test = test;
|
|
}
|
|
|
|
internal override bool Equals(Opcode op)
|
|
{
|
|
if (base.Equals(op))
|
|
{
|
|
return (((StartBooleanOpcode)op).test == this.test);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
internal override Opcode Eval(ProcessingContext context)
|
|
{
|
|
StackFrame sequences = context.TopSequenceArg;
|
|
Value[] values = context.Values;
|
|
StackFrame resultMask = context.TopArg;
|
|
Value[] sequenceBuffer = context.Sequences;
|
|
|
|
context.PushSequenceFrame();
|
|
for (int seqIndex = sequences.basePtr; seqIndex <= sequences.endPtr; ++seqIndex)
|
|
{
|
|
NodeSequence sourceSeq = sequenceBuffer[seqIndex].Sequence;
|
|
if (sourceSeq.Count > 0)
|
|
{
|
|
NodeSequenceItem[] items = sourceSeq.Items;
|
|
NodeSequence newSeq = null;
|
|
// Loop over the sequence, selecting those items for which the previous expression returned a result that
|
|
// matches the test value. Only those items will be processed further
|
|
// Note that the original position and size information is retained.
|
|
for (int i = resultMask.basePtr, n = 0; i <= resultMask.endPtr; ++i, ++n)
|
|
{
|
|
if (this.test == values[i].Boolean)
|
|
{
|
|
if (null == newSeq)
|
|
{
|
|
newSeq = context.CreateSequence();
|
|
}
|
|
newSeq.AddCopy(ref items[n], NodeSequence.GetContextSize(sourceSeq, n));
|
|
}
|
|
else
|
|
{
|
|
if (items[n].Last && null != newSeq)
|
|
{
|
|
newSeq.Items[newSeq.Count - 1].Last = true; // maintain nodeset boundaries...
|
|
}
|
|
}
|
|
}
|
|
context.PushSequence((null == newSeq) ? NodeSequence.Empty : newSeq);
|
|
newSeq = null;
|
|
}
|
|
}
|
|
|
|
return this.next;
|
|
}
|
|
|
|
#if DEBUG_FILTER
|
|
public override string ToString()
|
|
{
|
|
return string.Format("{0} {1}", base.ToString(), this.test);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// 'And' booleans: test is true
|
|
// 'Or' booleans: test is false
|
|
class EndBooleanOpcode : ApplyBooleanOpcode
|
|
{
|
|
internal EndBooleanOpcode(Opcode jump, bool test)
|
|
: base(OpcodeID.EndBoolean, jump, test)
|
|
{
|
|
}
|
|
|
|
internal override Opcode Eval(ProcessingContext context)
|
|
{
|
|
int matchCount = this.UpdateResultMask(context);
|
|
context.PopFrame();
|
|
context.PopSequenceFrame();
|
|
if (0 == matchCount)
|
|
{
|
|
return this.Jump;
|
|
}
|
|
|
|
return this.next;
|
|
}
|
|
}
|
|
|
|
class NoOpOpcode : Opcode
|
|
{
|
|
internal NoOpOpcode(OpcodeID id)
|
|
: base(id)
|
|
{
|
|
}
|
|
}
|
|
|
|
class BlockEndOpcode : Opcode
|
|
{
|
|
QueryBuffer<Opcode> sourceJumps;
|
|
|
|
internal BlockEndOpcode()
|
|
: base(OpcodeID.BlockEnd)
|
|
{
|
|
this.sourceJumps = new QueryBuffer<Opcode>(1);
|
|
}
|
|
|
|
internal void DeLinkJump(Opcode jump)
|
|
{
|
|
this.sourceJumps.Remove(jump);
|
|
}
|
|
|
|
internal void LinkJump(Opcode jump)
|
|
{
|
|
this.sourceJumps.Add(jump);
|
|
}
|
|
|
|
internal override void Remove()
|
|
{
|
|
// Before we can remove this blockEnd from the query tree, we have delink all jumps to it
|
|
while (this.sourceJumps.Count > 0)
|
|
{
|
|
((JumpOpcode)this.sourceJumps[0]).RemoveJump(this);
|
|
}
|
|
base.Remove();
|
|
}
|
|
|
|
}
|
|
|
|
class TypecastOpcode : Opcode
|
|
{
|
|
ValueDataType newType;
|
|
#if NO
|
|
internal TypecastOpcode(OpcodeID opcode, ValueDataType newType)
|
|
: base(opcode)
|
|
{
|
|
this.newType = newType;
|
|
}
|
|
#endif
|
|
internal TypecastOpcode(ValueDataType newType)
|
|
: base(OpcodeID.Cast)
|
|
{
|
|
this.newType = newType;
|
|
}
|
|
|
|
internal override bool Equals(Opcode op)
|
|
{
|
|
if (base.Equals(op))
|
|
{
|
|
return (this.newType == ((TypecastOpcode)op).newType);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
internal override Opcode Eval(ProcessingContext context)
|
|
{
|
|
StackFrame frame = context.TopArg;
|
|
Value[] values = context.Values;
|
|
for (int i = frame.basePtr; i <= frame.endPtr; ++i)
|
|
{
|
|
values[i].ConvertTo(context, newType);
|
|
}
|
|
|
|
return this.next;
|
|
}
|
|
|
|
#if DEBUG_FILTER
|
|
public override string ToString()
|
|
{
|
|
return string.Format("{0} {1}", base.ToString(), this.newType.ToString());
|
|
}
|
|
#endif
|
|
}
|
|
|
|
struct BranchContext
|
|
{
|
|
ProcessingContext branchContext;
|
|
ProcessingContext sourceContext;
|
|
|
|
internal BranchContext(ProcessingContext context)
|
|
{
|
|
this.sourceContext = context;
|
|
this.branchContext = null;
|
|
}
|
|
|
|
internal ProcessingContext Create()
|
|
{
|
|
if (null == this.branchContext)
|
|
{
|
|
this.branchContext = this.sourceContext.Clone();
|
|
}
|
|
else
|
|
{
|
|
this.branchContext.CopyFrom(this.sourceContext);
|
|
}
|
|
return this.branchContext;
|
|
}
|
|
|
|
internal void Release()
|
|
{
|
|
if (null != this.branchContext)
|
|
{
|
|
this.branchContext.Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
class QueryBranch
|
|
{
|
|
internal Opcode branch;
|
|
internal int id;
|
|
#if NO
|
|
internal QueryBranch(Opcode branch)
|
|
: this(branch, int.MinValue)
|
|
{
|
|
}
|
|
#endif
|
|
internal QueryBranch(Opcode branch, int id)
|
|
{
|
|
this.branch = branch;
|
|
this.id = id;
|
|
}
|
|
|
|
internal Opcode Branch
|
|
{
|
|
get
|
|
{
|
|
return this.branch;
|
|
}
|
|
#if NO
|
|
set
|
|
{
|
|
this.branch = value;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
internal int ID
|
|
{
|
|
get
|
|
{
|
|
return this.id;
|
|
}
|
|
}
|
|
}
|
|
|
|
class QueryBranchTable
|
|
{
|
|
int count;
|
|
QueryBranch[] branches;
|
|
|
|
internal QueryBranchTable()
|
|
: this(1)
|
|
{
|
|
}
|
|
|
|
internal QueryBranchTable(int capacity)
|
|
{
|
|
this.branches = new QueryBranch[capacity];
|
|
}
|
|
|
|
internal int Count
|
|
{
|
|
get
|
|
{
|
|
return this.count;
|
|
}
|
|
}
|
|
|
|
internal QueryBranch this[int index]
|
|
{
|
|
get
|
|
{
|
|
return this.branches[index];
|
|
}
|
|
}
|
|
#if NO
|
|
internal void Add(QueryBranch entry)
|
|
{
|
|
Fx.Assert(null != entry, "");
|
|
this.InsertAt(this.count, entry);
|
|
}
|
|
#endif
|
|
internal void AddInOrder(QueryBranch branch)
|
|
{
|
|
// Insert in sorted order always
|
|
int index;
|
|
for (index = 0; index < this.count; ++index)
|
|
{
|
|
// if current node is >= key, we've found the spot
|
|
if (this.branches[index].ID >= branch.ID)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
this.InsertAt(index, branch);
|
|
}
|
|
|
|
void Grow()
|
|
{
|
|
QueryBranch[] branches = new QueryBranch[this.branches.Length + 1];
|
|
Array.Copy(this.branches, branches, this.branches.Length);
|
|
this.branches = branches;
|
|
}
|
|
|
|
public int IndexOf(Opcode opcode)
|
|
{
|
|
for (int i = 0; i < this.count; ++i)
|
|
{
|
|
if (object.ReferenceEquals(opcode, this.branches[i].Branch))
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public int IndexOfID(int id)
|
|
{
|
|
for (int i = 0; i < this.count; ++i)
|
|
{
|
|
if (this.branches[i].ID == id)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
#if NO
|
|
public int IndexOfEquals(Opcode opcode)
|
|
{
|
|
for (int i = 0; i < this.count; ++i)
|
|
{
|
|
if (this.branches[i].Branch.Equals(opcode))
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
#endif
|
|
internal void InsertAt(int index, QueryBranch branch)
|
|
{
|
|
if (this.count == this.branches.Length)
|
|
{
|
|
this.Grow();
|
|
}
|
|
if (index < this.count)
|
|
{
|
|
Array.Copy(this.branches, index, this.branches, index + 1, this.count - index);
|
|
}
|
|
this.branches[index] = branch;
|
|
this.count++;
|
|
}
|
|
|
|
internal bool Remove(Opcode branch)
|
|
{
|
|
Fx.Assert(null != branch, "");
|
|
int index = this.IndexOf(branch);
|
|
if (index >= 0)
|
|
{
|
|
this.RemoveAt(index);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
internal void RemoveAt(int index)
|
|
{
|
|
Fx.Assert(index < this.count, "");
|
|
if (index < this.count - 1)
|
|
{
|
|
Array.Copy(this.branches, index + 1, this.branches, index, this.count - index - 1);
|
|
}
|
|
else
|
|
{
|
|
this.branches[index] = null;
|
|
}
|
|
this.count--;
|
|
}
|
|
|
|
internal void Trim()
|
|
{
|
|
if (this.count < this.branches.Length)
|
|
{
|
|
QueryBranch[] branches = new QueryBranch[this.count];
|
|
Array.Copy(this.branches, branches, this.count);
|
|
this.branches = branches;
|
|
}
|
|
|
|
for (int i = 0; i < this.branches.Length; ++i)
|
|
{
|
|
if (this.branches[i] != null && this.branches[i].Branch != null)
|
|
{
|
|
this.branches[i].Branch.Trim();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class BranchOpcode : Opcode
|
|
{
|
|
OpcodeList branches;
|
|
|
|
internal BranchOpcode()
|
|
: this(OpcodeID.Branch)
|
|
{
|
|
}
|
|
|
|
internal BranchOpcode(OpcodeID id)
|
|
: base(id)
|
|
{
|
|
this.flags |= OpcodeFlags.Branch;
|
|
this.branches = new OpcodeList(2);
|
|
}
|
|
|
|
internal OpcodeList Branches
|
|
{
|
|
get
|
|
{
|
|
return this.branches;
|
|
}
|
|
}
|
|
|
|
internal override void Add(Opcode opcode)
|
|
{
|
|
// Add with maximum affinity.. find a similar opcode, if we can, and call its Add method
|
|
for (int i = 0; i < this.branches.Count; ++i)
|
|
{
|
|
if (this.branches[i].IsEquivalentForAdd(opcode))
|
|
{
|
|
this.branches[i].Add(opcode);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Ok.. no similar opcode. Add it just like any other branch
|
|
this.AddBranch(opcode);
|
|
}
|
|
|
|
internal override void AddBranch(Opcode opcode)
|
|
{
|
|
Fx.Assert(null != opcode, "");
|
|
|
|
// Make sure the same opcode doesn't already exist..
|
|
Fx.Assert(-1 == this.branches.IndexOf(opcode), "");
|
|
this.branches.Add(opcode);
|
|
opcode.Prev = this;
|
|
|
|
// If this branch is in a conditional, then this new opcode must be added to that conditional..
|
|
if (this.IsInConditional())
|
|
{
|
|
this.LinkToConditional(opcode);
|
|
}
|
|
}
|
|
|
|
internal override void CollectXPathFilters(ICollection<MessageFilter> filters)
|
|
{
|
|
for (int i = 0; i < this.branches.Count; ++i)
|
|
{
|
|
this.branches[i].CollectXPathFilters(filters);
|
|
}
|
|
}
|
|
|
|
internal override void DelinkFromConditional(Opcode child)
|
|
{
|
|
if (null != this.prev)
|
|
{
|
|
this.prev.DelinkFromConditional(child);
|
|
}
|
|
}
|
|
internal override Opcode Eval(ProcessingContext context)
|
|
{
|
|
QueryProcessor processor = context.Processor;
|
|
SeekableXPathNavigator contextNode = processor.ContextNode;
|
|
int marker = processor.CounterMarker;
|
|
long pos = contextNode.CurrentPosition;
|
|
Opcode branch;
|
|
int i = 0;
|
|
int branchCount = this.branches.Count;
|
|
try
|
|
{
|
|
if (context.StacksInUse)
|
|
{
|
|
// If we have N branches, eval N-1 in a cloned context and the remainder in the
|
|
// original one
|
|
if (--branchCount > 0)
|
|
{
|
|
// Evaluate all but the first branch with a clone of the current context
|
|
// The first branch (right most) can be evaluated with the current context
|
|
BranchContext branchContext = new BranchContext(context); // struct. fast
|
|
for (; i < branchCount; ++i)
|
|
{
|
|
branch = this.branches[i];
|
|
if (0 != (branch.Flags & OpcodeFlags.Fx))
|
|
{
|
|
branch.Eval(context);
|
|
}
|
|
else
|
|
{
|
|
// This allocates a solitary context and then reuses it repeatedly
|
|
ProcessingContext newContext = branchContext.Create();
|
|
while (null != branch)
|
|
{
|
|
branch = branch.Eval(newContext);
|
|
}
|
|
}
|
|
contextNode.CurrentPosition = pos; // restore the navigator to its original position
|
|
processor.CounterMarker = marker; // and the node count marker
|
|
}
|
|
branchContext.Release();
|
|
}
|
|
|
|
// Do the final branch with the existing context
|
|
branch = branches[i];
|
|
while (null != branch)
|
|
{
|
|
branch = branch.Eval(context);
|
|
}
|
|
}
|
|
else // since there is nothing on the stack, there is nothing to clone
|
|
{
|
|
int nodeCountSav = context.NodeCount;
|
|
for (; i < branchCount; ++i)
|
|
{
|
|
branch = branches[i];
|
|
// Evaluate this branch
|
|
while (null != branch)
|
|
{
|
|
branch = branch.Eval(context);
|
|
}
|
|
// Restore the current context to its pristine state, so we can reuse it
|
|
context.ClearContext();
|
|
context.NodeCount = nodeCountSav;
|
|
contextNode.CurrentPosition = pos;
|
|
processor.CounterMarker = marker;
|
|
}
|
|
}
|
|
}
|
|
catch (XPathNavigatorException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(e.Process(branches[i]));
|
|
}
|
|
catch (NavigatorInvalidBodyAccessException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(e.Process(branches[i]));
|
|
}
|
|
processor.CounterMarker = marker;
|
|
|
|
return this.next;
|
|
}
|
|
|
|
internal override bool IsInConditional()
|
|
{
|
|
if (null != this.prev)
|
|
{
|
|
return this.prev.IsInConditional();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
internal override void LinkToConditional(Opcode child)
|
|
{
|
|
if (null != this.prev)
|
|
{
|
|
this.prev.LinkToConditional(child);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Loop over all branches, trying to locate one that is equal to the given opcode
|
|
/// If the branch is a branch itself, perform the locate recursively.
|
|
/// </summary>
|
|
/// <param name="opcode"></param>
|
|
/// <returns></returns>
|
|
internal override Opcode Locate(Opcode opcode)
|
|
{
|
|
Fx.Assert(!opcode.TestFlag(OpcodeFlags.Branch), "");
|
|
|
|
for (int i = 0, count = this.branches.Count; i < count; ++i)
|
|
{
|
|
Opcode branch = this.branches[i];
|
|
if (branch.TestFlag(OpcodeFlags.Branch))
|
|
{
|
|
// The branch is itself a branch. Since branch opcodes serve as branches in the exection
|
|
// path for a query, but don't comprise one of the opcodes used to actually perform it, we
|
|
// recursively try to locate an equivalent opcode inside the branch
|
|
Opcode subBranch = branch.Locate(opcode);
|
|
if (null != subBranch)
|
|
{
|
|
return subBranch;
|
|
}
|
|
}
|
|
else if (branch.Equals(opcode))
|
|
{
|
|
return branch;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
internal override void Remove()
|
|
{
|
|
if (0 == this.branches.Count)
|
|
{
|
|
base.Remove();
|
|
}
|
|
}
|
|
|
|
internal override void RemoveChild(Opcode opcode)
|
|
{
|
|
Fx.Assert(null != opcode, "");
|
|
|
|
if (this.IsInConditional())
|
|
{
|
|
this.DelinkFromConditional(opcode);
|
|
}
|
|
this.branches.Remove(opcode);
|
|
this.branches.Trim();
|
|
}
|
|
|
|
internal override void Replace(Opcode replace, Opcode with)
|
|
{
|
|
int i = this.branches.IndexOf(replace);
|
|
if (i >= 0)
|
|
{
|
|
replace.Prev = null;
|
|
this.branches[i] = with;
|
|
with.Prev = this;
|
|
}
|
|
}
|
|
|
|
internal override void Trim()
|
|
{
|
|
this.branches.Trim();
|
|
for (int i = 0; i < this.branches.Count; ++i)
|
|
{
|
|
this.branches[i].Trim();
|
|
}
|
|
}
|
|
}
|
|
|
|
struct QueryBranchResult
|
|
{
|
|
internal QueryBranch branch;
|
|
int valIndex;
|
|
|
|
internal QueryBranchResult(QueryBranch branch, int valIndex)
|
|
{
|
|
this.branch = branch;
|
|
this.valIndex = valIndex;
|
|
}
|
|
|
|
internal QueryBranch Branch
|
|
{
|
|
get
|
|
{
|
|
return this.branch;
|
|
}
|
|
}
|
|
|
|
internal int ValIndex
|
|
{
|
|
get
|
|
{
|
|
return this.valIndex;
|
|
}
|
|
}
|
|
#if NO
|
|
internal void Set(QueryBranch branch, int valIndex)
|
|
{
|
|
this.branch = branch;
|
|
this.valIndex = valIndex;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
internal class QueryBranchResultSet
|
|
{
|
|
QueryBuffer<QueryBranchResult> results;
|
|
QueryBranchResultSet next;
|
|
internal static SortComparer comparer = new SortComparer();
|
|
|
|
internal QueryBranchResultSet()
|
|
: this(2)
|
|
{
|
|
}
|
|
|
|
internal QueryBranchResultSet(int capacity)
|
|
{
|
|
this.results = new QueryBuffer<QueryBranchResult>(capacity);
|
|
}
|
|
|
|
internal int Count
|
|
{
|
|
get
|
|
{
|
|
return this.results.count;
|
|
}
|
|
}
|
|
|
|
internal QueryBranchResult this[int index]
|
|
{
|
|
get
|
|
{
|
|
return this.results[index];
|
|
}
|
|
}
|
|
|
|
internal QueryBranchResultSet Next
|
|
{
|
|
get
|
|
{
|
|
return this.next;
|
|
}
|
|
set
|
|
{
|
|
this.next = value;
|
|
}
|
|
}
|
|
|
|
internal void Add(QueryBranch branch, int valIndex)
|
|
{
|
|
this.results.Add(new QueryBranchResult(branch, valIndex));
|
|
}
|
|
|
|
internal void Clear()
|
|
{
|
|
this.results.count = 0;
|
|
}
|
|
|
|
internal void Sort()
|
|
{
|
|
this.results.Sort(QueryBranchResultSet.comparer);
|
|
}
|
|
|
|
internal class SortComparer : IComparer<QueryBranchResult>
|
|
{
|
|
public bool Equals(QueryBranchResult x, QueryBranchResult y)
|
|
{
|
|
return x.branch.id == y.branch.id;
|
|
}
|
|
public int Compare(QueryBranchResult x, QueryBranchResult y)
|
|
{
|
|
return x.branch.id - y.branch.id;
|
|
}
|
|
|
|
public int GetHashCode(QueryBranchResult obj)
|
|
{
|
|
return obj.branch.id;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct BranchMatcher
|
|
{
|
|
int resultCount;
|
|
QueryBranchResultSet resultTable;
|
|
|
|
internal BranchMatcher(int resultCount, QueryBranchResultSet resultTable)
|
|
{
|
|
this.resultCount = resultCount;
|
|
this.resultTable = resultTable;
|
|
}
|
|
|
|
internal QueryBranchResultSet ResultTable
|
|
{
|
|
get
|
|
{
|
|
return this.resultTable;
|
|
}
|
|
}
|
|
|
|
void InitResults(ProcessingContext context)
|
|
{
|
|
context.PushFrame();
|
|
// Push this.resultsCount booleans onto the stack, all set to false
|
|
context.Push(false, this.resultCount);
|
|
}
|
|
|
|
internal void InvokeMatches(ProcessingContext context)
|
|
{
|
|
Fx.Assert(null != context, "");
|
|
|
|
switch (this.resultTable.Count)
|
|
{
|
|
default:
|
|
this.InvokeMultiMatch(context);
|
|
break;
|
|
|
|
case 0:
|
|
break;
|
|
|
|
case 1:
|
|
this.InvokeSingleMatch(context);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void InvokeMultiMatch(ProcessingContext context)
|
|
{
|
|
int marker = context.Processor.CounterMarker;
|
|
BranchContext branchContext = new BranchContext(context); // struct. quick.
|
|
int resultTableCount = this.resultTable.Count;
|
|
for (int i = 0; i < resultTableCount; )
|
|
{
|
|
QueryBranchResult result = this.resultTable[i];
|
|
QueryBranch branch = result.Branch;
|
|
// Branches can arbitrarily alter context stacks, rendering them unuseable to other branches.
|
|
// Therefore, before following a branch, we have to clone the context. Cloning is relatively efficient because
|
|
// can avoid allocating memory in most cases. We cannot, unfortunately, avoid Array copies.
|
|
//
|
|
// Optimization:
|
|
// We can avoid cloning altogether when we can predict that the branch does NOT tamper with the stack,
|
|
// or does so in a predictable way. If we are sure that we can restore the stack easily after the branch
|
|
// completes, we have no reason to copy the stack.
|
|
ProcessingContext newContext;
|
|
Opcode nextOpcode = branch.Branch.Next;
|
|
if (nextOpcode.TestFlag(OpcodeFlags.NoContextCopy))
|
|
{
|
|
newContext = context;
|
|
}
|
|
else
|
|
{
|
|
newContext = branchContext.Create();
|
|
}
|
|
|
|
this.InitResults(newContext);
|
|
|
|
//
|
|
// Matches are sorted by their branch ID.
|
|
// It is very possible that the a literal matches multiple times, especially when the value being
|
|
// compared is a sequence. A literal may match multiple items in a single sequence
|
|
// OR multiple items in multiple sequences. If there were 4 context sequences, the literal may have
|
|
// matched one item each in 3 of them. The branchID for that literal will be present 3 times in the
|
|
// resultTable.
|
|
// Sorting the matches groups them by their branch Ids. We only want to take the branch ONCE, so now we
|
|
// iterate over all the duplicate matches..
|
|
// result.ValIndex will give us the index of the value that was matched. Thus if the 3rd sequence
|
|
// matched, ValIndex == 2 (0 based)
|
|
newContext.Values[newContext.TopArg[result.ValIndex]].Boolean = true;
|
|
while (++i < resultTableCount)
|
|
{
|
|
result = this.resultTable[i];
|
|
if (branch.ID == result.Branch.ID)
|
|
{
|
|
newContext.Values[newContext.TopArg[result.ValIndex]].Boolean = true;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
try
|
|
{
|
|
newContext.EvalCodeBlock(nextOpcode);
|
|
}
|
|
catch (XPathNavigatorException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(e.Process(nextOpcode));
|
|
}
|
|
catch (NavigatorInvalidBodyAccessException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(e.Process(nextOpcode));
|
|
}
|
|
context.Processor.CounterMarker = marker;
|
|
}
|
|
branchContext.Release();
|
|
}
|
|
|
|
internal void InvokeNonMatches(ProcessingContext context, QueryBranchTable nonMatchTable)
|
|
{
|
|
Fx.Assert(null != context && null != nonMatchTable, "");
|
|
|
|
int marker = context.Processor.CounterMarker;
|
|
BranchContext branchContext = new BranchContext(context);
|
|
int nonMatchIndex = 0;
|
|
int matchIndex = 0;
|
|
while (matchIndex < this.resultTable.Count && nonMatchIndex < nonMatchTable.Count)
|
|
{
|
|
int compare = this.resultTable[matchIndex].Branch.ID - nonMatchTable[nonMatchIndex].ID;
|
|
if (compare > 0)
|
|
{
|
|
// Nonmatch < match
|
|
// Invoke..
|
|
ProcessingContext newContext = branchContext.Create();
|
|
this.InvokeNonMatch(newContext, nonMatchTable[nonMatchIndex]);
|
|
context.Processor.CounterMarker = marker;
|
|
++nonMatchIndex;
|
|
}
|
|
else if (0 == compare)
|
|
{
|
|
++nonMatchIndex;
|
|
}
|
|
else
|
|
{
|
|
++matchIndex;
|
|
}
|
|
}
|
|
// Add remaining
|
|
while (nonMatchIndex < nonMatchTable.Count)
|
|
{
|
|
ProcessingContext newContext = branchContext.Create();
|
|
this.InvokeNonMatch(newContext, nonMatchTable[nonMatchIndex]);
|
|
context.Processor.CounterMarker = marker;
|
|
++nonMatchIndex;
|
|
}
|
|
branchContext.Release();
|
|
}
|
|
|
|
void InvokeNonMatch(ProcessingContext context, QueryBranch branch)
|
|
{
|
|
context.PushFrame();
|
|
context.Push(false, this.resultCount);
|
|
try
|
|
{
|
|
context.EvalCodeBlock(branch.Branch);
|
|
}
|
|
catch (XPathNavigatorException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(e.Process(branch.Branch));
|
|
}
|
|
catch (NavigatorInvalidBodyAccessException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(e.Process(branch.Branch));
|
|
}
|
|
}
|
|
|
|
void InvokeSingleMatch(ProcessingContext context)
|
|
{
|
|
int marker = context.Processor.CounterMarker;
|
|
QueryBranchResult result = this.resultTable[0];
|
|
this.InitResults(context);
|
|
context.Values[context.TopArg[result.ValIndex]].Boolean = true;
|
|
|
|
try
|
|
{
|
|
context.EvalCodeBlock(result.Branch.Branch.Next);
|
|
}
|
|
catch (XPathNavigatorException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(e.Process(result.Branch.Branch.Next));
|
|
}
|
|
catch (NavigatorInvalidBodyAccessException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(e.Process(result.Branch.Branch.Next));
|
|
}
|
|
|
|
context.Processor.CounterMarker = marker;
|
|
}
|
|
|
|
internal void Release(ProcessingContext context)
|
|
{
|
|
context.Processor.ReleaseResults(this.resultTable);
|
|
}
|
|
}
|
|
|
|
abstract class QueryBranchIndex
|
|
{
|
|
internal abstract int Count
|
|
{
|
|
get;
|
|
}
|
|
internal abstract QueryBranch this[object key]
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
internal abstract void CollectXPathFilters(ICollection<MessageFilter> filters);
|
|
|
|
#if NO
|
|
internal abstract IEnumerator GetEnumerator();
|
|
#endif
|
|
internal abstract void Match(int valIndex, ref Value val, QueryBranchResultSet results);
|
|
internal abstract void Remove(object key);
|
|
|
|
internal abstract void Trim();
|
|
}
|
|
|
|
class QueryConditionalBranchOpcode : Opcode
|
|
{
|
|
QueryBranchTable alwaysBranches;
|
|
QueryBranchIndex branchIndex;
|
|
int nextID;
|
|
|
|
internal QueryConditionalBranchOpcode(OpcodeID id, QueryBranchIndex branchIndex)
|
|
: base(id)
|
|
{
|
|
Fx.Assert(null != branchIndex, "");
|
|
this.flags |= OpcodeFlags.Branch;
|
|
this.branchIndex = branchIndex;
|
|
this.nextID = 0;
|
|
}
|
|
|
|
internal QueryBranchTable AlwaysBranches
|
|
{
|
|
get
|
|
{
|
|
if (null == this.alwaysBranches)
|
|
{
|
|
this.alwaysBranches = new QueryBranchTable();
|
|
}
|
|
return this.alwaysBranches;
|
|
}
|
|
}
|
|
#if NO
|
|
internal QueryBranchIndex BranchIndex
|
|
{
|
|
get
|
|
{
|
|
return this.branchIndex;
|
|
}
|
|
}
|
|
#endif
|
|
internal override void Add(Opcode opcode)
|
|
{
|
|
LiteralRelationOpcode literal = this.ValidateOpcode(opcode);
|
|
if (null == literal)
|
|
{
|
|
base.Add(opcode);
|
|
return;
|
|
}
|
|
|
|
// Was this literal already added to the index?
|
|
QueryBranch queryBranch = this.branchIndex[literal.Literal];
|
|
if (null == queryBranch)
|
|
{
|
|
// First time. New branch
|
|
this.nextID++;
|
|
queryBranch = new QueryBranch(literal, this.nextID);
|
|
literal.Prev = this;
|
|
this.branchIndex[literal.Literal] = queryBranch;
|
|
}
|
|
else
|
|
{
|
|
Fx.Assert(!object.ReferenceEquals(queryBranch.Branch, literal), "");
|
|
Fx.Assert(literal.ID == queryBranch.Branch.ID, "");
|
|
// literal already exists.. but what follows the literal must be branched
|
|
// Should never get here, but just in case
|
|
queryBranch.Branch.Next.Add(literal.Next);
|
|
}
|
|
literal.Flags |= OpcodeFlags.InConditional;
|
|
|
|
this.AddAlwaysBranch(queryBranch, literal.Next);
|
|
}
|
|
|
|
internal void AddAlwaysBranch(Opcode literal, Opcode next)
|
|
{
|
|
LiteralRelationOpcode literalOp = this.ValidateOpcode(literal);
|
|
Fx.Assert(null != literalOp, "");
|
|
if (null != literalOp)
|
|
{
|
|
this.AddAlwaysBranch(literalOp, next);
|
|
}
|
|
}
|
|
|
|
// Whether or not the given literal matches, we must always take the branch rooted at 'next'
|
|
// Add to the AlwaysBranches table if not already there..
|
|
internal void AddAlwaysBranch(LiteralRelationOpcode literal, Opcode next)
|
|
{
|
|
Fx.Assert(null != literal && null != next, "");
|
|
|
|
QueryBranch literalBranch = this.branchIndex[literal.Literal];
|
|
Fx.Assert(null != literalBranch, "");
|
|
|
|
this.AddAlwaysBranch(literalBranch, next);
|
|
}
|
|
|
|
void AddAlwaysBranch(QueryBranch literalBranch, Opcode next)
|
|
{
|
|
if (OpcodeID.Branch == next.ID)
|
|
{
|
|
BranchOpcode opcode = (BranchOpcode)next;
|
|
OpcodeList branches = opcode.Branches;
|
|
for (int i = 0; i < branches.Count; ++i)
|
|
{
|
|
Opcode branch = branches[i];
|
|
if (this.IsAlwaysBranch(branch))
|
|
{
|
|
this.AlwaysBranches.AddInOrder(new QueryBranch(branch, literalBranch.ID));
|
|
}
|
|
else
|
|
{
|
|
branch.Flags |= OpcodeFlags.NoContextCopy;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Fx.Assert(!next.TestFlag(OpcodeFlags.Branch), "");
|
|
if (this.IsAlwaysBranch(next))
|
|
{
|
|
this.AlwaysBranches.AddInOrder(new QueryBranch(next, literalBranch.ID));
|
|
}
|
|
else
|
|
{
|
|
next.Flags |= OpcodeFlags.NoContextCopy;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal virtual void CollectMatches(int valIndex, ref Value val, QueryBranchResultSet results)
|
|
{
|
|
this.branchIndex.Match(valIndex, ref val, results);
|
|
}
|
|
|
|
internal override void CollectXPathFilters(ICollection<MessageFilter> filters)
|
|
{
|
|
if (this.alwaysBranches != null)
|
|
{
|
|
for (int i = 0; i < this.alwaysBranches.Count; ++i)
|
|
{
|
|
this.alwaysBranches[i].Branch.CollectXPathFilters(filters);
|
|
}
|
|
}
|
|
|
|
this.branchIndex.CollectXPathFilters(filters);
|
|
}
|
|
|
|
internal override Opcode Eval(ProcessingContext context)
|
|
{
|
|
StackFrame arg = context.TopArg;
|
|
int argCount = arg.Count;
|
|
|
|
if (argCount > 0)
|
|
{
|
|
QueryBranchResultSet resultSet = context.Processor.CreateResultSet();
|
|
BranchMatcher matcher = new BranchMatcher(argCount, resultSet);
|
|
// Operate on values at the the top frame of the value stack
|
|
// For each source value, find the branch that could be taken
|
|
for (int i = 0; i < argCount; ++i)
|
|
{
|
|
this.CollectMatches(i, ref context.Values[arg[i]], resultSet);
|
|
}
|
|
// Done with whatever we were testing equality against
|
|
context.PopFrame();
|
|
if (resultSet.Count > 1)
|
|
{
|
|
// Sort results
|
|
resultSet.Sort();
|
|
}
|
|
|
|
// First, do non-true branches..
|
|
if (null != this.alwaysBranches && this.alwaysBranches.Count > 0)
|
|
{
|
|
matcher.InvokeNonMatches(context, this.alwaysBranches);
|
|
}
|
|
|
|
// Iterate through matches, invoking each matched branch
|
|
matcher.InvokeMatches(context);
|
|
|
|
matcher.Release(context);
|
|
}
|
|
else
|
|
{
|
|
context.PopFrame();
|
|
}
|
|
return this.next;
|
|
}
|
|
|
|
internal QueryBranch GetBranch(Opcode op)
|
|
{
|
|
if (op.TestFlag(OpcodeFlags.Literal))
|
|
{
|
|
LiteralRelationOpcode relOp = this.ValidateOpcode(op);
|
|
if (null != relOp)
|
|
{
|
|
QueryBranch branch = this.branchIndex[relOp.Literal];
|
|
if (null != branch && branch.Branch.ID == op.ID)
|
|
{
|
|
return branch;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
bool IsAlwaysBranch(Opcode next)
|
|
{
|
|
Fx.Assert(null != next, "");
|
|
|
|
// Opcodes subsequent to matching literals must obviously be branched to.
|
|
// The question is whether we should branch to the opcodes following those literals that do *not* match.
|
|
// Naturally, the answer depends on the sort of opcode that succeeds the literal.
|
|
//
|
|
// If the literal is within a boolean conjunction, the succeeding opcode will either be a JumpIfNot
|
|
// Or a BlockEnd.
|
|
//
|
|
// -If the JumpIfNot is multiway, then always evaluate if it contains ANY non-result only opcodes.
|
|
// -If JumpIfNot(False) -i.e. AND - only evaluate if the opcode succeeding the jump is NOT a result opcode.
|
|
// -If JumpIfNot(True) - i.e. OR - always evaluate
|
|
//
|
|
// -If BlockEnd - evaluate only if not followed by a result
|
|
//
|
|
// When branching for matching literals, we push trues onto the ValueStack corresponding to the items that
|
|
// matched. When branching for non-matching literals, we push ALL FALSE values... and then eval.
|
|
|
|
// is it a the termination of a conditional?
|
|
JumpIfOpcode jump = next as JumpIfOpcode;
|
|
if (null != jump)
|
|
{
|
|
// Is the conditional JumpIfNot(False) = i.e. OR?
|
|
if (!jump.Test)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Does the conditional actually jump to anything? Should never be the case, but paranoia demands..
|
|
Opcode jumpTo = jump.Jump;
|
|
if (null == jumpTo)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Lets see where the jump will take us
|
|
Opcode postJump;
|
|
if (jumpTo.TestFlag(OpcodeFlags.Branch))
|
|
{
|
|
// Multiway jump
|
|
OpcodeList branches = ((BranchOpcode)jumpTo).Branches;
|
|
for (int i = 0; i < branches.Count; ++i)
|
|
{
|
|
postJump = branches[i].Next;
|
|
if (null != postJump && !postJump.TestFlag(OpcodeFlags.Result))
|
|
{
|
|
// There is at least one jump here that leads to a non-result.
|
|
// For now, this dooms everybody to being branched to, whether or not their respective literals
|
|
// matched
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// single jump
|
|
postJump = jump.Jump.Next;
|
|
if (null != postJump && postJump.TestFlag(OpcodeFlags.Result))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// If the next opcode is a BlockEnd, then only bother processing if what follows the block is not a result
|
|
if (OpcodeID.BlockEnd == next.ID)
|
|
{
|
|
Fx.Assert(null != next.Next, "");
|
|
return (!next.Next.TestFlag(OpcodeFlags.Result));
|
|
}
|
|
|
|
// The literal is not inside a boolean conjunction
|
|
// If the literal is not followed by a result, then we must do further processing after the branch
|
|
return (!next.TestFlag(OpcodeFlags.Result));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if this branch can accept 'opcode' being added to it
|
|
/// </summary>
|
|
internal override bool IsEquivalentForAdd(Opcode opcode)
|
|
{
|
|
if (null != this.ValidateOpcode(opcode))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return base.IsEquivalentForAdd(opcode);
|
|
}
|
|
|
|
internal override Opcode Locate(Opcode opcode)
|
|
{
|
|
QueryBranch queryBranch = this.GetBranch(opcode);
|
|
if (null != queryBranch)
|
|
{
|
|
return queryBranch.Branch;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
internal override void Remove()
|
|
{
|
|
if (null == this.branchIndex || 0 == this.branchIndex.Count)
|
|
{
|
|
base.Remove();
|
|
}
|
|
}
|
|
|
|
internal override void RemoveChild(Opcode opcode)
|
|
{
|
|
LiteralRelationOpcode literal = this.ValidateOpcode(opcode);
|
|
Fx.Assert(null != literal, "");
|
|
|
|
QueryBranch branch = this.branchIndex[literal.Literal];
|
|
Fx.Assert(null != branch, "");
|
|
this.branchIndex.Remove(literal.Literal);
|
|
branch.Branch.Flags &= (~OpcodeFlags.NoContextCopy);
|
|
if (null != this.alwaysBranches)
|
|
{
|
|
int removeAt = this.alwaysBranches.IndexOfID(branch.ID);
|
|
if (removeAt >= 0)
|
|
{
|
|
this.alwaysBranches.RemoveAt(removeAt);
|
|
if (0 == this.alwaysBranches.Count)
|
|
{
|
|
this.alwaysBranches = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void RemoveAlwaysBranch(Opcode opcode)
|
|
{
|
|
if (null == this.alwaysBranches)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Note: if the opcodes below are not in the alwaysBranches table, nothing will happen
|
|
// So arbitrary calls are safe - just makes the removal processor slower (we'll speed it up if necessary)
|
|
if (OpcodeID.Branch == opcode.ID)
|
|
{
|
|
OpcodeList branches = ((BranchOpcode)opcode).Branches;
|
|
for (int i = 0; i < branches.Count; ++i)
|
|
{
|
|
this.alwaysBranches.Remove(branches[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.alwaysBranches.Remove(opcode);
|
|
}
|
|
if (0 == this.alwaysBranches.Count)
|
|
{
|
|
this.alwaysBranches = null;
|
|
}
|
|
}
|
|
|
|
internal override void Replace(Opcode replace, Opcode with)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new NotImplementedException(SR.GetString(SR.FilterUnexpectedError)));
|
|
}
|
|
|
|
internal override void Trim()
|
|
{
|
|
if (this.alwaysBranches != null)
|
|
{
|
|
this.alwaysBranches.Trim();
|
|
}
|
|
this.branchIndex.Trim();
|
|
}
|
|
|
|
internal virtual LiteralRelationOpcode ValidateOpcode(Opcode opcode)
|
|
{
|
|
return opcode as LiteralRelationOpcode;
|
|
}
|
|
}
|
|
}
|