static EmptyArrayWithRoles()
{
var state = new ArrayState <TValue>(null);
var arrayIQ = new ArrayImmutableQueryImpl <TValue, TValueQuery, TValueImmutable>(state);
ARRAY = new ArrayWithRolesImpl <TValue, TValueQuery, TValueImmutable>(new ArrayQueryOfMutablesImpl <TValue, TValueQuery, TValueImmutable>(arrayIQ, new ArrayQueryOfQueriesImpl <TValue, TValueQuery, TValueImmutable>(arrayIQ, state), state), state);
}
static EmptyArrayProxy()
{
// Can not cache this to CollectionsFactoryImpl since it is not generic class.
var state = new ArrayState <TValue>(null);
ARRAY = new ArrayProxyImpl <TValue>(new ArrayProxyQueryImpl <TValue>(state), state);
}
// From measurements it seems we spend very little time in this method
public bool LessEqual(ArrayState a)
{
Contract.Requires(this.PluginsCount == a.PluginsCount);
bool result;
if (AbstractDomainsHelper.TryTrivialLessEqual(this, a, out result))
{
return(result);
}
if (!this.Array.LessEqual(a.Array))
{
return(false);
}
if (!this.Numerical.LessEqual(a.Numerical))
{
return(false);
}
for (var i = 0; i < this.PluginsCount; i++)
{
if (!this.PluginAbstractStateAt(i).LessEqual(a.PluginAbstractStateAt(i)))
{
return(false);
}
}
return(true);
}
public ArrayParser(ArrayState state)
{
_state = state;
switch (state)
{
case ArrayState.ReadyForFirst:
// NextChar(ValueParser.ValueStarts, c => ValueParser.ParserForValue(c).ReturningTo(new ArrayParser(ArrayState.JustReadValue).ReturningTo(Return)));
NextCanBeValueReturningTo(() => new ArrayParser(ArrayState.JustReadValue).ReturningTo(Return));
NextChar(StructuralChar.Whitespace, () => this); // Ignore it
NextChar(StructuralChar.ArrayEnd, () => new ArrayParser(ArrayState.Completed).ReturningTo(Return));
break;
case ArrayState.ReadyForNext:
// NextChar(ValueParser.ValueStarts, c => ValueParser.ParserForValue(c).ReturningTo(new ArrayParser(ArrayState.JustReadValue).ReturningTo(Return)));
NextCanBeValueReturningTo(() => new ArrayParser(ArrayState.JustReadValue).ReturningTo(Return));
break;
case ArrayState.JustReadValue:
NextChar(StructuralChar.Whitespace, () => this); // Ignore it
NextChar(StructuralChar.Comma, () => new ArrayParser(ArrayState.ReadyForNext).ReturningTo(Return));
NextChar(StructuralChar.ArrayEnd, () => new ArrayParser(ArrayState.Completed).ReturningTo(Return));
break;
case ArrayState.Completed:
break;
default:
throw new ArgumentOutOfRangeException(nameof(state), state, null);
}
}
public ArrayState Meet(ArrayState a)
{
Contract.Requires(this.PluginsCount == a.PluginsCount);
Contract.Ensures(Contract.Result <ArrayState>() != null);
Contract.Ensures(Contract.Result <ArrayState>().PluginsCount == this.PluginsCount);
ArrayState result;
if (AbstractDomainsHelper.TryTrivialMeet(this, a, out result))
{
return(result);
}
#if DEBUG
// F: for debugging
result = null;
#endif
var array = this.Array.Meet(a.Array);
var numerical = this.Numerical.Meet(a.Numerical) as INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression>;
var plugins = new IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression> [this.PluginsCount];
for (var i = 0; i < this.PluginsCount; i++)
{
plugins[i] = this.PluginAbstractStateAt(i).Meet(a.PluginAbstractStateAt(i)) as IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression>;
}
return(new ArrayState(array, numerical, plugins, this.mappings));
}
private void MoveToInitial(XmlDictionaryReaderQuotas quotas, XmlBinaryReaderSession session, OnXmlDictionaryReaderClose onClose)
{
MoveToInitial(quotas);
_maxBytesPerRead = quotas.MaxBytesPerRead;
_arrayState = ArrayState.None;
_isTextWithEndElement = false;
}
AssignInParallel(Dictionary <BoxedVariable <Variable>, FList <BoxedVariable <Variable> > > refinedMap,
Converter <BoxedVariable <Variable>, BoxedExpression> convert, List <Pair <NormalizedExpression <BoxedVariable <Variable> >, NormalizedExpression <BoxedVariable <Variable> > > > equalities,
ArrayState state)
{
Contract.Assume(refinedMap != null);
Contract.Assume(convert != null);
var renamed = Select(state);
renamed.AssignInParallel(refinedMap, convert);
return(renamed);
}
public override ArrayState HelperForAssignInParallel(
ArrayState state,
Pair <APC, APC> edge, Dictionary <BoxedVariable <Variable>, FList <BoxedVariable <Variable> > > refinedMap,
Converter <BoxedVariable <Variable>, BoxedExpression> convert)
{
Contract.Assume(state != null);
var mySubState = Select(state);
mySubState.AssignInParallel(refinedMap, convert);
return(state.UpdatePluginAt(this.Id, mySubState));
}
AssumeExistsAll(APC pc, ExistsIndexedExpression exists, ArrayState data)
{
Contract.Requires(exists != null);
Contract.Requires(data != null);
// F: those are readonly-fields to which we cannot attach postcondition
Contract.Assume(exists.LowerBound != null);
Contract.Assume(exists.UpperBound != null);
var mySubState = Select(data);
// Shortcut for Exists(false => ...)
if (exists.LowerBound.Equals(exists.UpperBound))
{
return(mySubState.Bottom
as ArraySegmentationEnvironment <NonRelationalValueAbstraction <BoxedVariable <Variable>, BoxedExpression>, BoxedVariable <Variable>, BoxedExpression>);
}
NonRelationalValueAbstraction <BoxedVariable <Variable>, BoxedExpression> intv;
BoxedExpression array;
if (this.TryInferNonRelationalProperty(exists.BoundVariable, exists.Body, data.Numerical, out array, out intv))
{
var arrayVar = ((Variable)array.UnderlyingVariable);
Variable arrayLen;
if ((array.UnderlyingVariable is Variable) &&
this.Context.ValueContext.TryGetArrayLength(this.Context.MethodContext.CFG.Post(pc), arrayVar, out arrayLen))
{
Contract.Assume(arrayLen != null); // Clousot does not know arrayLen is a struct here
ArraySegmentation <NonRelationalValueAbstraction <BoxedVariable <Variable>, BoxedExpression>, BoxedVariable <Variable>, BoxedExpression>
arraySegmentation;
if (this.TryCreateArraySegment(exists.LowerBound, exists.UpperBound, arrayLen, intv, data.Numerical, out arraySegmentation))
{
ArraySegmentation <NonRelationalValueAbstraction <BoxedVariable <Variable>, BoxedExpression>, BoxedVariable <Variable>, BoxedExpression> prevVal;
if (mySubState.TryGetValue(ToBoxedVariable(arrayVar), out prevVal))
{
var meet = prevVal.Meet(arraySegmentation);
mySubState.Update(ToBoxedVariable(arrayVar), meet);
}
else
{
mySubState.AddElement(ToBoxedVariable(arrayVar), arraySegmentation);
}
}
}
}
return(mySubState);
}
public ArrayTracking Select(ArrayState state)
{
Contract.Requires(state != null);
Contract.Requires(this.Id < state.PluginsCount);
Contract.Ensures(Contract.Result <ArrayTracking>() != null);
var untyped = state.PluginAbstractStateAt(this.Id);
var selected = untyped as ArrayTracking;
Contract.Assume(selected != null);
return(selected);
}
private ADictionary Select(ArrayState state)
{
Contract.Requires(state != null);
Contract.Ensures(Contract.Result <ADictionary>() != null);
Contract.Assume(-1 <= this.Id, "assuming the global invariant");
Contract.Assume(this.Id < state.PluginsCount, "assuming the global invariant");
var result = state.PluginAbstractStateAt(this.Id) as ADictionary;
Contract.Assume(result != null, "Wrong type!!!");
return(result);
}
Select(ArrayState state)
{
Contract.Requires(state != null);
Contract.Ensures(Contract.Result <ArraySegmentationEnvironment <TwoValuesLattice <BoxedVariable <Variable> >, BoxedVariable <Variable>, BoxedExpression> >() != null);
Contract.Assume(this.Id < state.PluginsCount, "Assuming the global invariant");
var untyped = state.PluginAbstractStateAt(this.Id);
var selected = untyped as ArraySegmentationEnvironment <TwoValuesLattice <BoxedVariable <Variable> >, BoxedVariable <Variable>, BoxedExpression>;
Contract.Assume(selected != null);
return(selected);
}
public override IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression> AssignInParallel(
Dictionary <BoxedVariable <Variable>, FList <BoxedVariable <Variable> > > refinedMap,
Converter <BoxedVariable <Variable>, BoxedExpression> convert, List <Pair <NormalizedExpression <BoxedVariable <Variable> >, NormalizedExpression <BoxedVariable <Variable> > > > equalities,
ArrayState state)
{
Contract.Assume(state != null);
Contract.Assume(refinedMap != null, "missing preconditions in base class");
Contract.Assume(convert != null, "missing preconditions in base class");
var mySubState = Select(state);
mySubState.AssignInParallel(refinedMap, convert);
return(mySubState);
}
public override IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression> AssignInParallel(
Dictionary <BoxedVariable <Variable>, FList <BoxedVariable <Variable> > > refinedMap,
Converter <BoxedVariable <Variable>, BoxedExpression> convert, List <Pair <NormalizedExpression <BoxedVariable <Variable> >, NormalizedExpression <BoxedVariable <Variable> > > > equalities,
ArrayState state)
{
Contract.Assume(state != null, "Problem with the extractor of CC");
Contract.Assume(refinedMap != null, "Problem with the extractor of CC");
Contract.Assume(convert != null, "Problem with the extractor of CC");
var renamed = Select(state);
renamed.AssignInParallel(refinedMap, convert);
return(renamed);
}
public override IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression> AssignInParallel(
Dictionary <BoxedVariable <Variable>, FList <BoxedVariable <Variable> > > refinedMap,
Converter <BoxedVariable <Variable>, BoxedExpression> convert,
List <Pair <NormalizedExpression <BoxedVariable <Variable> >, NormalizedExpression <BoxedVariable <Variable> > > > equalities,
ArrayState state)
{
Contract.Requires(refinedMap != null);
Contract.Requires(convert != null);
Contract.Requires(equalities != null);
Contract.Requires(state != null);
Contract.Ensures(Contract.Result <IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression> >() != null);
return(default(IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression>));
}
Select(ArrayState state)
{
Contract.Requires(state != null);
Contract.Requires(this.Id < state.PluginsCount);
Contract.Ensures(
Contract.Result <
ArraySegmentationEnvironment <
FlatAbstractDomainOfBoolsWithRenaming <BoxedVariable <Variable> >, BoxedVariable <Variable>, BoxedExpression> >() != null);
var subState = state.PluginAbstractStateAt(this.Id)
as ArraySegmentationEnvironment <FlatAbstractDomainOfBoolsWithRenaming <BoxedVariable <Variable> >, BoxedVariable <Variable>, BoxedExpression>;
Contract.Assume(subState != null);
return(subState);
}
protected bool TryInferSegmentEquality(BoxedExpression index, BoxedExpression body,
ArrayState state,
out BoxedExpression leftArray, out BoxedExpression rightArray, out AbstractDomain meet)
{
BinaryOperator bop;
BoxedExpression.ArrayIndexExpression <Type> left, right;
if (body.TryFindArrayExpBinOpArrayExp(index, out bop, out left, out right) && bop == BinaryOperator.Ceq)
{
// we know we have the expression "left == right"
leftArray = left.Array;
rightArray = right.Array;
}
leftArray = rightArray = default(BoxedExpression);
meet = default(AbstractDomain);
return(false);
}
private ArrayState AssumeCheckOfAnArrayElement(APC pc, Variable var, ArrayState data)
{
Contract.Requires(data != null);
Contract.Ensures(Contract.Result <ArrayState>() != null);
Pair <BoxedVariable <Variable>, BoxedVariable <Variable> > refined;
if (data.CanRefineToArrayLoad(new BoxedVariable <Variable>(var), out refined))
{
var mySubState = Select(data);
ArraySegmentation <
FlatAbstractDomainOfBoolsWithRenaming <BoxedVariable <Variable> >, BoxedVariable <Variable>, BoxedExpression> segmentation;
Contract.Assume(refined.One != null);
Contract.Assume(refined.Two != null);
// Do we have a segmentation?
foreach (var arr in GetEquals(pc, refined.One, data))
{
if (mySubState.TryGetValue(arr, out segmentation))
{
// Is it unmodified?
if (data.IsUnmodifiedArrayElementFromEntry(arr, ToBoxedExpression(pc, refined.Two)))
{
var norm = ToBoxedExpression(pc, refined.Two).ToNormalizedExpression <Variable>();
if (norm != null && segmentation.TrySetAbstractValue(norm, CHECKED, data.Numerical, out segmentation))
{
mySubState.Update(arr, segmentation);
}
else
{
mySubState.RemoveElement(arr);
}
data = data.UpdatePluginAt(this.Id, mySubState);
}
}
}
}
return(data);
}
private Token Step(int character, ArrayState newState, ArrayTokenType newArrayTokenType, bool create = false)
{
Token res = null;
if (create)
{
res = new Token((int)_arrayTokenType, Text.ToString());
Text.Clear();
}
if (character != IgnoreChar)
{
Text.Append((char)character);
}
CurrentState = newState;
_arrayTokenType = newArrayTokenType;
return(res);
}
public ArrayState Widening(ArrayState a)
{
Contract.Requires(this.PluginsCount == a.PluginsCount);
Contract.Ensures(Contract.Result <ArrayState>() != null);
Contract.Ensures(Contract.Result <ArrayState>().PluginsCount == this.PluginsCount);
ArrayState result;
if (AbstractDomainsHelper.TryTrivialJoin(this, a, out result))
{
return(result);
}
#if DEBUG
// F: for debugging
result = null;
#endif
ArraySegmentationEnvironment <NonRelationalValueAbstraction <BoxedVariable <Variable>, BoxedExpression>, BoxedVariable <Variable>, BoxedExpression> array = null;
INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression> numerical = null;
#if PARALLELWIDENING
var arrayTask = Task.Run(() => array = this.Array.Widening(a.Array));
var numericalTask = Task.Run(() => numerical = this.Numerical.Widening(a.Numerical) as INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression>);
#else
array = this.Array.Widening(a.Array);
numerical = this.Numerical.Widening(a.Numerical) as INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression>;
#endif
var plugins = new IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression> [this.PluginsCount];
for (var i = 0; i < this.PluginsCount; i++)
{
plugins[i] = this.PluginAbstractStateAt(i).Widening(a.PluginAbstractStateAt(i)) as IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression>;
}
#if PARALLELWIDENING
Task.WaitAll(arrayTask, numericalTask);
#endif
return(new ArrayState(array, numerical, plugins, this.mappings));
}
public override ArrayState Entry(APC pc, Method method, ArrayState data)
{
Contract.Assume(data != null);
var resultState = data;
var arrayParamCount = 0;
// We materialize all the arrays in the parameters...
foreach (var param in this.DecoderForMetaData.Parameters(method).Enumerate())
{
Variable symb;
var postPC = Context.MethodContext.CFG.Post(pc);
if (this.Context.ValueContext.TryParameterValue(postPC, param, out symb))
{
var paramType = this.DecoderForMetaData.ParameterType(param);
if (this.DecoderForMetaData.IsArray(paramType))
{
arrayParamCount++;
var dummy = MaterializeArray(postPC, Select(resultState), resultState.Numerical.CheckIfNonZero, symb, UNMODIFIED, UNMODIFIED);
}
else
{
foreach (var intf in this.DecoderForMetaData.Interfaces(paramType))
{
if (this.DecoderForMetaData.Name(intf).AssumeNotNull().Contains("IEnumerable"))
{
var dummy = MaterializeEnumerable(postPC, Select(resultState), symb, UNMODIFIED);
}
}
}
}
}
#if false && DEBUG
if (arrayParamCount > 0)
{
Console.WriteLine("Method contains {0} array params", arrayParamCount);
}
#endif
return(resultState);
}
private void AppendValue(string s)
{
bool needSeparator = false;
if (state_.Count > 0)
{
var state = state_.Peek();
ArrayState arrayState = state as ArrayState;
if (arrayState != null)
{
needSeparator = arrayState.ElementsCount > 0;
arrayState.ElementsCount++;
}
}
if (needSeparator)
{
builder_.Append(", ");
}
builder_.Append(s);
}
public override ArrayState Entry(APC pc, Method method, ArrayState data)
{
Contract.Assume(data != null);
var mySubState = Select(data);
// We materialize all the arrays in the parameters...
foreach (var param in this.DecoderForMetaData.Parameters(method).Enumerate())
{
Variable symb;
var postPC = Context.MethodContext.CFG.Post(pc);
if (
this.Context.ValueContext.TryParameterValue(postPC, param, out symb))
{
if (this.DecoderForMetaData.IsArray(DecoderForMetaData.ParameterType(param)))
{
var dummy = MaterializeArray(
postPC, mySubState,
data.Numerical.CheckIfNonZero, symb, UNCHECKED,
new FlatAbstractDomainOfBoolsWithRenaming <BoxedVariable <Variable> >(FlatAbstractDomain <bool> .State.Bottom));
}
else
{
var paramType = this.DecoderForMetaData.ParameterType(param);
foreach (var intf in this.DecoderForMetaData.Interfaces(paramType))
{
if (this.DecoderForMetaData.Name(intf).AssumeNotNull().Contains("IEnumerable"))
{
var dummy = MaterializeEnumerable(postPC, mySubState, symb, UNCHECKED);
}
}
}
}
}
return(data.UpdatePluginAt(this.Id, mySubState));
}
public override ArrayState Entry(APC pc, Method method, ArrayState data)
{
return(MakeState(this.enumAnalysis.Entry(pc, method, Select(data)), data));
}
private void ReadArray()
{
if (this.GetNodeType() == XmlBinaryNodeType.Array)
{
XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
}
this.ReadNode();
if (base.Node.NodeType != XmlNodeType.Element)
{
XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
}
if (this.GetNodeType() == XmlBinaryNodeType.Array)
{
XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
}
this.ReadNode();
if (base.Node.NodeType != XmlNodeType.EndElement)
{
XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
}
this.arrayState = ArrayState.Element;
this.arrayNodeType = this.GetNodeType();
if (!this.IsValidArrayType(this.arrayNodeType))
{
XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
}
this.SkipNodeType();
this.arrayCount = this.ReadMultiByteUInt31();
if (this.arrayCount == 0)
{
XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
}
this.MoveToArrayElement();
}
private static bool hasState(int currState, ArrayState state)
{
return((currState & (int)state) > 0);
}
private void MoveToArrayElement()
{
this.arrayState = ArrayState.Element;
base.MoveToNode(base.ElementNode);
}
public override bool Read()
{
if (base.Node.ReadState == System.Xml.ReadState.Closed)
{
return false;
}
base.SignNode();
if (this.isTextWithEndElement)
{
this.isTextWithEndElement = false;
base.MoveToEndElement();
return true;
}
if (this.arrayState == ArrayState.Content)
{
if (this.arrayCount != 0)
{
this.MoveToArrayElement();
return true;
}
this.arrayState = ArrayState.None;
}
if (base.Node.ExitScope)
{
base.ExitScope();
}
return this.ReadNode();
}
private bool ReadNode()
{
if (!_buffered)
BufferReader.SetWindow(ElementNode.BufferOffset, _maxBytesPerRead);
if (BufferReader.EndOfFile)
{
MoveToEndOfFile();
return false;
}
XmlBinaryNodeType nodeType;
if (_arrayState == ArrayState.None)
{
nodeType = GetNodeType();
SkipNodeType();
}
else
{
DiagnosticUtility.DebugAssert(_arrayState == ArrayState.Element, "");
nodeType = _arrayNodeType;
_arrayCount--;
_arrayState = ArrayState.Content;
}
XmlElementNode elementNode;
PrefixHandleType prefix;
switch (nodeType)
{
case XmlBinaryNodeType.ShortElement:
elementNode = EnterScope();
elementNode.Prefix.SetValue(PrefixHandleType.Empty);
ReadName(elementNode.LocalName);
ReadAttributes();
elementNode.Namespace = LookupNamespace(PrefixHandleType.Empty);
elementNode.BufferOffset = BufferReader.Offset;
return true;
case XmlBinaryNodeType.Element:
elementNode = EnterScope();
ReadName(elementNode.Prefix);
ReadName(elementNode.LocalName);
ReadAttributes();
elementNode.Namespace = LookupNamespace(elementNode.Prefix);
elementNode.BufferOffset = BufferReader.Offset;
return true;
case XmlBinaryNodeType.ShortDictionaryElement:
elementNode = EnterScope();
elementNode.Prefix.SetValue(PrefixHandleType.Empty);
ReadDictionaryName(elementNode.LocalName);
ReadAttributes();
elementNode.Namespace = LookupNamespace(PrefixHandleType.Empty);
elementNode.BufferOffset = BufferReader.Offset;
return true;
case XmlBinaryNodeType.DictionaryElement:
elementNode = EnterScope();
ReadName(elementNode.Prefix);
ReadDictionaryName(elementNode.LocalName);
ReadAttributes();
elementNode.Namespace = LookupNamespace(elementNode.Prefix);
elementNode.BufferOffset = BufferReader.Offset;
return true;
case XmlBinaryNodeType.PrefixElementA:
case XmlBinaryNodeType.PrefixElementB:
case XmlBinaryNodeType.PrefixElementC:
case XmlBinaryNodeType.PrefixElementD:
case XmlBinaryNodeType.PrefixElementE:
case XmlBinaryNodeType.PrefixElementF:
case XmlBinaryNodeType.PrefixElementG:
case XmlBinaryNodeType.PrefixElementH:
case XmlBinaryNodeType.PrefixElementI:
case XmlBinaryNodeType.PrefixElementJ:
case XmlBinaryNodeType.PrefixElementK:
case XmlBinaryNodeType.PrefixElementL:
case XmlBinaryNodeType.PrefixElementM:
case XmlBinaryNodeType.PrefixElementN:
case XmlBinaryNodeType.PrefixElementO:
case XmlBinaryNodeType.PrefixElementP:
case XmlBinaryNodeType.PrefixElementQ:
case XmlBinaryNodeType.PrefixElementR:
case XmlBinaryNodeType.PrefixElementS:
case XmlBinaryNodeType.PrefixElementT:
case XmlBinaryNodeType.PrefixElementU:
case XmlBinaryNodeType.PrefixElementV:
case XmlBinaryNodeType.PrefixElementW:
case XmlBinaryNodeType.PrefixElementX:
case XmlBinaryNodeType.PrefixElementY:
case XmlBinaryNodeType.PrefixElementZ:
elementNode = EnterScope();
prefix = PrefixHandle.GetAlphaPrefix((int)nodeType - (int)XmlBinaryNodeType.PrefixElementA);
elementNode.Prefix.SetValue(prefix);
ReadName(elementNode.LocalName);
ReadAttributes();
elementNode.Namespace = LookupNamespace(prefix);
elementNode.BufferOffset = BufferReader.Offset;
return true;
case XmlBinaryNodeType.PrefixDictionaryElementA:
case XmlBinaryNodeType.PrefixDictionaryElementB:
case XmlBinaryNodeType.PrefixDictionaryElementC:
case XmlBinaryNodeType.PrefixDictionaryElementD:
case XmlBinaryNodeType.PrefixDictionaryElementE:
case XmlBinaryNodeType.PrefixDictionaryElementF:
case XmlBinaryNodeType.PrefixDictionaryElementG:
case XmlBinaryNodeType.PrefixDictionaryElementH:
case XmlBinaryNodeType.PrefixDictionaryElementI:
case XmlBinaryNodeType.PrefixDictionaryElementJ:
case XmlBinaryNodeType.PrefixDictionaryElementK:
case XmlBinaryNodeType.PrefixDictionaryElementL:
case XmlBinaryNodeType.PrefixDictionaryElementM:
case XmlBinaryNodeType.PrefixDictionaryElementN:
case XmlBinaryNodeType.PrefixDictionaryElementO:
case XmlBinaryNodeType.PrefixDictionaryElementP:
case XmlBinaryNodeType.PrefixDictionaryElementQ:
case XmlBinaryNodeType.PrefixDictionaryElementR:
case XmlBinaryNodeType.PrefixDictionaryElementS:
case XmlBinaryNodeType.PrefixDictionaryElementT:
case XmlBinaryNodeType.PrefixDictionaryElementU:
case XmlBinaryNodeType.PrefixDictionaryElementV:
case XmlBinaryNodeType.PrefixDictionaryElementW:
case XmlBinaryNodeType.PrefixDictionaryElementX:
case XmlBinaryNodeType.PrefixDictionaryElementY:
case XmlBinaryNodeType.PrefixDictionaryElementZ:
elementNode = EnterScope();
prefix = PrefixHandle.GetAlphaPrefix((int)nodeType - (int)XmlBinaryNodeType.PrefixDictionaryElementA);
elementNode.Prefix.SetValue(prefix);
ReadDictionaryName(elementNode.LocalName);
ReadAttributes();
elementNode.Namespace = LookupNamespace(prefix);
elementNode.BufferOffset = BufferReader.Offset;
return true;
case XmlBinaryNodeType.EndElement:
MoveToEndElement();
return true;
case XmlBinaryNodeType.Comment:
ReadName(MoveToComment().Value);
return true;
case XmlBinaryNodeType.EmptyTextWithEndElement:
MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.Empty);
if (this.OutsideRootElement)
VerifyWhitespace();
return true;
case XmlBinaryNodeType.ZeroTextWithEndElement:
MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.Zero);
if (this.OutsideRootElement)
VerifyWhitespace();
return true;
case XmlBinaryNodeType.OneTextWithEndElement:
MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.One);
if (this.OutsideRootElement)
VerifyWhitespace();
return true;
case XmlBinaryNodeType.TrueTextWithEndElement:
MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.True);
if (this.OutsideRootElement)
VerifyWhitespace();
return true;
case XmlBinaryNodeType.FalseTextWithEndElement:
MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.False);
if (this.OutsideRootElement)
VerifyWhitespace();
return true;
case XmlBinaryNodeType.BoolTextWithEndElement:
MoveToAtomicTextWithEndElement().Value.SetValue(ReadUInt8() != 0 ? ValueHandleType.True : ValueHandleType.False);
if (this.OutsideRootElement)
VerifyWhitespace();
return true;
case XmlBinaryNodeType.Chars8TextWithEndElement:
if (_buffered)
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.UTF8, ReadUInt8());
else
ReadPartialUTF8Text(true, ReadUInt8());
return true;
case XmlBinaryNodeType.Chars8Text:
if (_buffered)
ReadText(MoveToComplexText(), ValueHandleType.UTF8, ReadUInt8());
else
ReadPartialUTF8Text(false, ReadUInt8());
return true;
case XmlBinaryNodeType.Chars16TextWithEndElement:
if (_buffered)
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.UTF8, ReadUInt16());
else
ReadPartialUTF8Text(true, ReadUInt16());
return true;
case XmlBinaryNodeType.Chars16Text:
if (_buffered)
ReadText(MoveToComplexText(), ValueHandleType.UTF8, ReadUInt16());
else
ReadPartialUTF8Text(false, ReadUInt16());
return true;
case XmlBinaryNodeType.Chars32TextWithEndElement:
if (_buffered)
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.UTF8, ReadUInt31());
else
ReadPartialUTF8Text(true, ReadUInt31());
return true;
case XmlBinaryNodeType.Chars32Text:
if (_buffered)
ReadText(MoveToComplexText(), ValueHandleType.UTF8, ReadUInt31());
else
ReadPartialUTF8Text(false, ReadUInt31());
return true;
case XmlBinaryNodeType.UnicodeChars8TextWithEndElement:
ReadUnicodeText(true, ReadUInt8());
return true;
case XmlBinaryNodeType.UnicodeChars8Text:
ReadUnicodeText(false, ReadUInt8());
return true;
case XmlBinaryNodeType.UnicodeChars16TextWithEndElement:
ReadUnicodeText(true, ReadUInt16());
return true;
case XmlBinaryNodeType.UnicodeChars16Text:
ReadUnicodeText(false, ReadUInt16());
return true;
case XmlBinaryNodeType.UnicodeChars32TextWithEndElement:
ReadUnicodeText(true, ReadUInt31());
return true;
case XmlBinaryNodeType.UnicodeChars32Text:
ReadUnicodeText(false, ReadUInt31());
return true;
case XmlBinaryNodeType.Bytes8TextWithEndElement:
if (_buffered)
ReadBinaryText(MoveToAtomicTextWithEndElement(), ReadUInt8());
else
ReadPartialBinaryText(true, ReadUInt8());
return true;
case XmlBinaryNodeType.Bytes8Text:
if (_buffered)
ReadBinaryText(MoveToComplexText(), ReadUInt8());
else
ReadPartialBinaryText(false, ReadUInt8());
return true;
case XmlBinaryNodeType.Bytes16TextWithEndElement:
if (_buffered)
ReadBinaryText(MoveToAtomicTextWithEndElement(), ReadUInt16());
else
ReadPartialBinaryText(true, ReadUInt16());
return true;
case XmlBinaryNodeType.Bytes16Text:
if (_buffered)
ReadBinaryText(MoveToComplexText(), ReadUInt16());
else
ReadPartialBinaryText(false, ReadUInt16());
return true;
case XmlBinaryNodeType.Bytes32TextWithEndElement:
if (_buffered)
ReadBinaryText(MoveToAtomicTextWithEndElement(), ReadUInt31());
else
ReadPartialBinaryText(true, ReadUInt31());
return true;
case XmlBinaryNodeType.Bytes32Text:
if (_buffered)
ReadBinaryText(MoveToComplexText(), ReadUInt31());
else
ReadPartialBinaryText(false, ReadUInt31());
return true;
case XmlBinaryNodeType.DictionaryTextWithEndElement:
MoveToAtomicTextWithEndElement().Value.SetDictionaryValue(ReadDictionaryKey());
return true;
case XmlBinaryNodeType.UniqueIdTextWithEndElement:
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.UniqueId, ValueHandleLength.UniqueId);
return true;
case XmlBinaryNodeType.GuidTextWithEndElement:
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Guid, ValueHandleLength.Guid);
return true;
case XmlBinaryNodeType.DecimalTextWithEndElement:
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Decimal, ValueHandleLength.Decimal);
return true;
case XmlBinaryNodeType.Int8TextWithEndElement:
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Int8, ValueHandleLength.Int8);
return true;
case XmlBinaryNodeType.Int16TextWithEndElement:
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Int16, ValueHandleLength.Int16);
return true;
case XmlBinaryNodeType.Int32TextWithEndElement:
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Int32, ValueHandleLength.Int32);
return true;
case XmlBinaryNodeType.Int64TextWithEndElement:
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Int64, ValueHandleLength.Int64);
return true;
case XmlBinaryNodeType.UInt64TextWithEndElement:
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.UInt64, ValueHandleLength.UInt64);
return true;
case XmlBinaryNodeType.FloatTextWithEndElement:
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Single, ValueHandleLength.Single);
return true;
case XmlBinaryNodeType.DoubleTextWithEndElement:
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Double, ValueHandleLength.Double);
return true;
case XmlBinaryNodeType.TimeSpanTextWithEndElement:
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.TimeSpan, ValueHandleLength.TimeSpan);
return true;
case XmlBinaryNodeType.DateTimeTextWithEndElement:
ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.DateTime, ValueHandleLength.DateTime);
return true;
case XmlBinaryNodeType.QNameDictionaryTextWithEndElement:
BufferReader.ReadQName(MoveToAtomicTextWithEndElement().Value);
return true;
case XmlBinaryNodeType.Array:
ReadArray();
return true;
default:
BufferReader.ReadValue(nodeType, MoveToComplexText().Value);
return true;
}
}
public override ArrayState Stfld(APC pc, Field field, bool @volatile, Variable obj, Variable value, ArrayState data)
{
return(MakeState(this.enumAnalysis.Stfld(pc, field, @volatile, obj, value, Select(data)), data));
}
private void SkipArrayElements(int count)
{
_arrayCount -= count;
if (_arrayCount == 0)
{
_arrayState = ArrayState.None;
ExitScope();
ReadNode();
}
}
private void ReadArray()
{
if (GetNodeType() == XmlBinaryNodeType.Array) // Prevent recursion
XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
ReadNode(); // ReadStartElement
if (this.Node.NodeType != XmlNodeType.Element)
XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
if (GetNodeType() == XmlBinaryNodeType.Array) // Prevent recursion
XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
ReadNode(); // ReadEndElement
if (this.Node.NodeType != XmlNodeType.EndElement)
XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
_arrayState = ArrayState.Element;
_arrayNodeType = GetNodeType();
if (!IsValidArrayType(_arrayNodeType))
XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
SkipNodeType();
_arrayCount = ReadMultiByteUInt31();
if (_arrayCount == 0)
XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
MoveToArrayElement();
}
public ArrayState MakeState(EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> newSubState, ArrayState oldState)
{
return(oldState.UpdatePluginAt(this.Id, newSubState));
}
public EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> Select(ArrayState state)
{
Contract.Requires(state != null);
Contract.Requires(this.Id < state.PluginsCount);
Contract.Ensures(Contract.Result <EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> >() != null);
var untyped = state.PluginAbstractStateAt(this.Id);
var selected = untyped as EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression>;
Contract.Assume(selected != null);
return(selected);
}
public override ArrayState Ldfld(APC pc, Field field, bool @volatile, Variable dest, Variable obj, ArrayState data)
{
return(MakeState(this.enumAnalysis.Ldfld(pc, field, @volatile, dest, obj, Select(data)), data));
}
private void MoveToArrayElement()
{
_arrayState = ArrayState.Element;
MoveToNode(ElementNode);
}
public override ArrayState Assume(APC pc, string tag, Variable source, object provenance, ArrayState data)
{
var newData = data;
var newSubState = this.enumAnalysis.Assume(pc, tag, source, provenance, Select(data));
// At this point, we may know more on enums, so let's push them to the numerical domain
if (newSubState.IsNormal())
{
var mdDecoder = this.DecoderForMetaData;
var numericalDomain = data.Numerical;
foreach (var pair in newSubState.DefinedVariables)
{
List <int> typeValues;
// TODO: We may be smarted, and avoid recomputing the enum values if we already saw the type
var type = pair.One;
if (mdDecoder.IsEnumWithoutFlagAttribute(type) && mdDecoder.TryGetEnumValues(type, out typeValues))
{
// Assume the variable is in the enum
numericalDomain.AssumeInDisInterval(pair.Two, DisInterval.For(typeValues));
}
}
newData = newData.UpdateNumerical(numericalDomain);
}
return(MakeState(newSubState, newData));
}
public override bool Read()
{
if (this.Node.ReadState == ReadState.Closed)
return false;
if (_isTextWithEndElement)
{
_isTextWithEndElement = false;
MoveToEndElement();
return true;
}
if (_arrayState == ArrayState.Content)
{
if (_arrayCount != 0)
{
MoveToArrayElement();
return true;
}
_arrayState = ArrayState.None;
}
if (this.Node.ExitScope)
{
ExitScope();
}
return ReadNode();
}
private bool ReadNode()
{
XmlBinaryNodeType nodeType;
XmlBaseReader.XmlElementNode node;
PrefixHandleType alphaPrefix;
if (!this.buffered)
{
base.BufferReader.SetWindow(base.ElementNode.BufferOffset, this.maxBytesPerRead);
}
if (base.BufferReader.EndOfFile)
{
base.MoveToEndOfFile();
return false;
}
if (this.arrayState == ArrayState.None)
{
nodeType = this.GetNodeType();
this.SkipNodeType();
}
else
{
nodeType = this.arrayNodeType;
this.arrayCount--;
this.arrayState = ArrayState.Content;
}
switch (nodeType)
{
case XmlBinaryNodeType.EndElement:
base.MoveToEndElement();
return true;
case XmlBinaryNodeType.Comment:
this.ReadName(base.MoveToComment().Value);
return true;
case XmlBinaryNodeType.Array:
this.ReadArray();
return true;
case XmlBinaryNodeType.MinElement:
node = base.EnterScope();
node.Prefix.SetValue(PrefixHandleType.Empty);
this.ReadName(node.LocalName);
this.ReadAttributes();
node.Namespace = base.LookupNamespace(PrefixHandleType.Empty);
node.BufferOffset = base.BufferReader.Offset;
return true;
case XmlBinaryNodeType.Element:
node = base.EnterScope();
this.ReadName(node.Prefix);
this.ReadName(node.LocalName);
this.ReadAttributes();
node.Namespace = base.LookupNamespace(node.Prefix);
node.BufferOffset = base.BufferReader.Offset;
return true;
case XmlBinaryNodeType.ShortDictionaryElement:
node = base.EnterScope();
node.Prefix.SetValue(PrefixHandleType.Empty);
this.ReadDictionaryName(node.LocalName);
this.ReadAttributes();
node.Namespace = base.LookupNamespace(PrefixHandleType.Empty);
node.BufferOffset = base.BufferReader.Offset;
return true;
case XmlBinaryNodeType.DictionaryElement:
node = base.EnterScope();
this.ReadName(node.Prefix);
this.ReadDictionaryName(node.LocalName);
this.ReadAttributes();
node.Namespace = base.LookupNamespace(node.Prefix);
node.BufferOffset = base.BufferReader.Offset;
return true;
case XmlBinaryNodeType.PrefixDictionaryElementA:
case XmlBinaryNodeType.PrefixDictionaryElementB:
case XmlBinaryNodeType.PrefixDictionaryElementC:
case XmlBinaryNodeType.PrefixDictionaryElementD:
case XmlBinaryNodeType.PrefixDictionaryElementE:
case XmlBinaryNodeType.PrefixDictionaryElementF:
case XmlBinaryNodeType.PrefixDictionaryElementG:
case XmlBinaryNodeType.PrefixDictionaryElementH:
case XmlBinaryNodeType.PrefixDictionaryElementI:
case XmlBinaryNodeType.PrefixDictionaryElementJ:
case XmlBinaryNodeType.PrefixDictionaryElementK:
case XmlBinaryNodeType.PrefixDictionaryElementL:
case XmlBinaryNodeType.PrefixDictionaryElementM:
case XmlBinaryNodeType.PrefixDictionaryElementN:
case XmlBinaryNodeType.PrefixDictionaryElementO:
case XmlBinaryNodeType.PrefixDictionaryElementP:
case XmlBinaryNodeType.PrefixDictionaryElementQ:
case XmlBinaryNodeType.PrefixDictionaryElementR:
case XmlBinaryNodeType.PrefixDictionaryElementS:
case XmlBinaryNodeType.PrefixDictionaryElementT:
case XmlBinaryNodeType.PrefixDictionaryElementU:
case XmlBinaryNodeType.PrefixDictionaryElementV:
case XmlBinaryNodeType.PrefixDictionaryElementW:
case XmlBinaryNodeType.PrefixDictionaryElementX:
case XmlBinaryNodeType.PrefixDictionaryElementY:
case XmlBinaryNodeType.PrefixDictionaryElementZ:
node = base.EnterScope();
alphaPrefix = PrefixHandle.GetAlphaPrefix(((int) nodeType) - 0x44);
node.Prefix.SetValue(alphaPrefix);
this.ReadDictionaryName(node.LocalName);
this.ReadAttributes();
node.Namespace = base.LookupNamespace(alphaPrefix);
node.BufferOffset = base.BufferReader.Offset;
return true;
case XmlBinaryNodeType.PrefixElementA:
case XmlBinaryNodeType.PrefixElementB:
case XmlBinaryNodeType.PrefixElementC:
case XmlBinaryNodeType.PrefixElementD:
case XmlBinaryNodeType.PrefixElementE:
case XmlBinaryNodeType.PrefixElementF:
case XmlBinaryNodeType.PrefixElementG:
case XmlBinaryNodeType.PrefixElementH:
case XmlBinaryNodeType.PrefixElementI:
case XmlBinaryNodeType.PrefixElementJ:
case XmlBinaryNodeType.PrefixElementK:
case XmlBinaryNodeType.PrefixElementL:
case XmlBinaryNodeType.PrefixElementM:
case XmlBinaryNodeType.PrefixElementN:
case XmlBinaryNodeType.PrefixElementO:
case XmlBinaryNodeType.PrefixElementP:
case XmlBinaryNodeType.PrefixElementQ:
case XmlBinaryNodeType.PrefixElementR:
case XmlBinaryNodeType.PrefixElementS:
case XmlBinaryNodeType.PrefixElementT:
case XmlBinaryNodeType.PrefixElementU:
case XmlBinaryNodeType.PrefixElementV:
case XmlBinaryNodeType.PrefixElementW:
case XmlBinaryNodeType.PrefixElementX:
case XmlBinaryNodeType.PrefixElementY:
case XmlBinaryNodeType.PrefixElementZ:
node = base.EnterScope();
alphaPrefix = PrefixHandle.GetAlphaPrefix(((int) nodeType) - 0x5e);
node.Prefix.SetValue(alphaPrefix);
this.ReadName(node.LocalName);
this.ReadAttributes();
node.Namespace = base.LookupNamespace(alphaPrefix);
node.BufferOffset = base.BufferReader.Offset;
return true;
case XmlBinaryNodeType.ZeroTextWithEndElement:
this.MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.Zero);
if (base.OutsideRootElement)
{
this.VerifyWhitespace();
}
return true;
case XmlBinaryNodeType.OneTextWithEndElement:
this.MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.One);
if (base.OutsideRootElement)
{
this.VerifyWhitespace();
}
return true;
case XmlBinaryNodeType.FalseTextWithEndElement:
this.MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.False);
if (base.OutsideRootElement)
{
this.VerifyWhitespace();
}
return true;
case XmlBinaryNodeType.TrueTextWithEndElement:
this.MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.True);
if (base.OutsideRootElement)
{
this.VerifyWhitespace();
}
return true;
case XmlBinaryNodeType.Int8TextWithEndElement:
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.Int8, 1);
return true;
case XmlBinaryNodeType.Int16TextWithEndElement:
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.Int16, 2);
return true;
case XmlBinaryNodeType.Int32TextWithEndElement:
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.Int32, 4);
return true;
case XmlBinaryNodeType.Int64TextWithEndElement:
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.Int64, 8);
return true;
case XmlBinaryNodeType.FloatTextWithEndElement:
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.Single, 4);
return true;
case XmlBinaryNodeType.DoubleTextWithEndElement:
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.Double, 8);
return true;
case XmlBinaryNodeType.DecimalTextWithEndElement:
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.Decimal, 0x10);
return true;
case XmlBinaryNodeType.DateTimeTextWithEndElement:
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.DateTime, 8);
return true;
case XmlBinaryNodeType.Chars8Text:
if (!this.buffered)
{
this.ReadPartialUTF8Text(false, this.ReadUInt8());
}
else
{
this.ReadText(base.MoveToComplexText(), ValueHandleType.UTF8, this.ReadUInt8());
}
return true;
case XmlBinaryNodeType.Chars8TextWithEndElement:
if (!this.buffered)
{
this.ReadPartialUTF8Text(true, this.ReadUInt8());
break;
}
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.UTF8, this.ReadUInt8());
break;
case XmlBinaryNodeType.Chars16Text:
if (!this.buffered)
{
this.ReadPartialUTF8Text(false, this.ReadUInt16());
}
else
{
this.ReadText(base.MoveToComplexText(), ValueHandleType.UTF8, this.ReadUInt16());
}
return true;
case XmlBinaryNodeType.Chars16TextWithEndElement:
if (!this.buffered)
{
this.ReadPartialUTF8Text(true, this.ReadUInt16());
}
else
{
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.UTF8, this.ReadUInt16());
}
return true;
case XmlBinaryNodeType.Chars32Text:
if (!this.buffered)
{
this.ReadPartialUTF8Text(false, this.ReadUInt31());
}
else
{
this.ReadText(base.MoveToComplexText(), ValueHandleType.UTF8, this.ReadUInt31());
}
return true;
case XmlBinaryNodeType.Chars32TextWithEndElement:
if (!this.buffered)
{
this.ReadPartialUTF8Text(true, this.ReadUInt31());
}
else
{
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.UTF8, this.ReadUInt31());
}
return true;
case XmlBinaryNodeType.Bytes8Text:
if (!this.buffered)
{
this.ReadPartialBinaryText(false, this.ReadUInt8());
}
else
{
this.ReadBinaryText(base.MoveToComplexText(), this.ReadUInt8());
}
return true;
case XmlBinaryNodeType.Bytes8TextWithEndElement:
if (!this.buffered)
{
this.ReadPartialBinaryText(true, this.ReadUInt8());
}
else
{
this.ReadBinaryText(this.MoveToAtomicTextWithEndElement(), this.ReadUInt8());
}
return true;
case XmlBinaryNodeType.Bytes16Text:
if (!this.buffered)
{
this.ReadPartialBinaryText(false, this.ReadUInt16());
}
else
{
this.ReadBinaryText(base.MoveToComplexText(), this.ReadUInt16());
}
return true;
case XmlBinaryNodeType.Bytes16TextWithEndElement:
if (!this.buffered)
{
this.ReadPartialBinaryText(true, this.ReadUInt16());
}
else
{
this.ReadBinaryText(this.MoveToAtomicTextWithEndElement(), this.ReadUInt16());
}
return true;
case XmlBinaryNodeType.Bytes32Text:
if (!this.buffered)
{
this.ReadPartialBinaryText(false, this.ReadUInt31());
}
else
{
this.ReadBinaryText(base.MoveToComplexText(), this.ReadUInt31());
}
return true;
case XmlBinaryNodeType.Bytes32TextWithEndElement:
if (!this.buffered)
{
this.ReadPartialBinaryText(true, this.ReadUInt31());
}
else
{
this.ReadBinaryText(this.MoveToAtomicTextWithEndElement(), this.ReadUInt31());
}
return true;
case XmlBinaryNodeType.EmptyTextWithEndElement:
this.MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.Empty);
if (base.OutsideRootElement)
{
this.VerifyWhitespace();
}
return true;
case XmlBinaryNodeType.DictionaryTextWithEndElement:
this.MoveToAtomicTextWithEndElement().Value.SetDictionaryValue(this.ReadDictionaryKey());
return true;
case XmlBinaryNodeType.UniqueIdTextWithEndElement:
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.UniqueId, 0x10);
return true;
case XmlBinaryNodeType.TimeSpanTextWithEndElement:
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.TimeSpan, 8);
return true;
case XmlBinaryNodeType.GuidTextWithEndElement:
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.Guid, 0x10);
return true;
case XmlBinaryNodeType.UInt64TextWithEndElement:
this.ReadText(this.MoveToAtomicTextWithEndElement(), ValueHandleType.UInt64, 8);
return true;
case XmlBinaryNodeType.BoolTextWithEndElement:
this.MoveToAtomicTextWithEndElement().Value.SetValue((this.ReadUInt8() != 0) ? ValueHandleType.True : ValueHandleType.False);
if (base.OutsideRootElement)
{
this.VerifyWhitespace();
}
return true;
case XmlBinaryNodeType.UnicodeChars8Text:
this.ReadUnicodeText(false, this.ReadUInt8());
return true;
case XmlBinaryNodeType.UnicodeChars8TextWithEndElement:
this.ReadUnicodeText(true, this.ReadUInt8());
return true;
case XmlBinaryNodeType.UnicodeChars16Text:
this.ReadUnicodeText(false, this.ReadUInt16());
return true;
case XmlBinaryNodeType.UnicodeChars16TextWithEndElement:
this.ReadUnicodeText(true, this.ReadUInt16());
return true;
case XmlBinaryNodeType.UnicodeChars32Text:
this.ReadUnicodeText(false, this.ReadUInt31());
return true;
case XmlBinaryNodeType.UnicodeChars32TextWithEndElement:
this.ReadUnicodeText(true, this.ReadUInt31());
return true;
case XmlBinaryNodeType.QNameDictionaryTextWithEndElement:
base.BufferReader.ReadQName(this.MoveToAtomicTextWithEndElement().Value);
return true;
default:
base.BufferReader.ReadValue(nodeType, base.MoveToComplexText().Value);
return true;
}
return true;
}
public override ArrayState Ldloc(APC pc, Local local, Variable dest, ArrayState data)
{
return(MakeState(this.enumAnalysis.Ldloc(pc, local, dest, Select(data)), data));
}
private void SkipArrayElements(int count)
{
this.arrayCount -= count;
if (this.arrayCount == 0)
{
this.arrayState = ArrayState.None;
base.ExitScope();
this.ReadNode();
}
}
