private void ReadObjectNull(BinaryHeaderEnum binaryHeaderEnum)
{
SerTrace.Log(this, "ReadObjectNull ");
if (objectNull == null)
{
objectNull = new ObjectNull();
}
objectNull.Read(this, binaryHeaderEnum);
objectNull.Dump();
ObjectProgress objectOp = (ObjectProgress)stack.Peek();
prs.Init();
prs.PRparseTypeEnum = InternalParseTypeE.Member;
prs.PRmemberValueEnum = InternalMemberValueE.Null;
if (objectOp.objectTypeEnum == InternalObjectTypeE.Object)
{
prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
prs.PRname = objectOp.name;
prs.PRdtType = objectOp.dtType;
}
else
{
prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
prs.PRnullCount = objectNull.nullCount;
//only one null position has been incremented by GetNext
//The position needs to be reset for the rest of the nulls
objectOp.ArrayCountIncrement(objectNull.nullCount - 1);
}
objectReader.Parse(prs);
}
private void ReadMemberPrimitiveUnTyped()
{
ObjectProgress objectProgress = (ObjectProgress)this.stack.Peek();
if (this.memberPrimitiveUnTyped == null)
{
this.memberPrimitiveUnTyped = new MemberPrimitiveUnTyped();
}
this.memberPrimitiveUnTyped.Set((InternalPrimitiveTypeE)this.expectedTypeInformation);
this.memberPrimitiveUnTyped.Read(this);
this.memberPrimitiveUnTyped.Dump();
this.prs.Init();
this.prs.PRvarValue = this.memberPrimitiveUnTyped.value;
this.prs.PRdtTypeCode = (InternalPrimitiveTypeE)this.expectedTypeInformation;
this.prs.PRdtType = Converter.ToType(this.prs.PRdtTypeCode);
this.prs.PRparseTypeEnum = InternalParseTypeE.Member;
this.prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
if (objectProgress.objectTypeEnum == InternalObjectTypeE.Object)
{
this.prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
this.prs.PRname = objectProgress.name;
}
else
{
this.prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
}
this.objectReader.Parse(this.prs);
}
private void ReadMemberPrimitiveUnTyped()
{
SerTrace.Log(this, "ReadMemberPrimitiveUnTyped ");
ObjectProgress objectOp = (ObjectProgress)stack.Peek();
if (memberPrimitiveUnTyped == null)
{
memberPrimitiveUnTyped = new MemberPrimitiveUnTyped();
}
memberPrimitiveUnTyped.Set((InternalPrimitiveTypeE)expectedTypeInformation);
memberPrimitiveUnTyped.Read(this);
memberPrimitiveUnTyped.Dump();
prs.Init();
prs.PRvarValue = memberPrimitiveUnTyped.value;
prs.PRdtTypeCode = (InternalPrimitiveTypeE)expectedTypeInformation;
prs.PRdtType = Converter.ToType(prs.PRdtTypeCode);
prs.PRparseTypeEnum = InternalParseTypeE.Member;
prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
if (objectOp.objectTypeEnum == InternalObjectTypeE.Object)
{
prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
prs.PRname = objectOp.name;
}
else
{
prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
}
objectReader.Parse(prs);
}
private void ReadMemberReference()
{
SerTrace.Log(this, "ReadMemberReference ");
if (memberReference == null)
{
memberReference = new MemberReference();
}
memberReference.Read(this);
memberReference.Dump();
ObjectProgress objectOp = (ObjectProgress)stack.Peek();
prs.Init();
prs.PRidRef = objectReader.GetId((long)memberReference.idRef);
prs.PRparseTypeEnum = InternalParseTypeE.Member;
prs.PRmemberValueEnum = InternalMemberValueE.Reference;
if (objectOp.objectTypeEnum == InternalObjectTypeE.Object)
{
prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
prs.PRname = objectOp.name;
prs.PRdtType = objectOp.dtType;
}
else
{
prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
}
objectReader.Parse(prs);
}
private void ReadMemberPrimitiveUnTyped()
{
ObjectProgress objectOp = (ObjectProgress)_stack.Peek();
if (memberPrimitiveUnTyped == null)
{
memberPrimitiveUnTyped = new MemberPrimitiveUnTyped();
}
memberPrimitiveUnTyped.Set((InternalPrimitiveTypeE)_expectedTypeInformation);
memberPrimitiveUnTyped.Read(this);
PRs.Init();
PRs._varValue = memberPrimitiveUnTyped._value;
PRs._dtTypeCode = (InternalPrimitiveTypeE)_expectedTypeInformation;
PRs._dtType = Converter.ToType(PRs._dtTypeCode);
PRs._parseTypeEnum = InternalParseTypeE.Member;
PRs._memberValueEnum = InternalMemberValueE.InlineValue;
if (objectOp._objectTypeEnum == InternalObjectTypeE.Object)
{
PRs._memberTypeEnum = InternalMemberTypeE.Field;
PRs._name = objectOp._name;
}
else
{
PRs._memberTypeEnum = InternalMemberTypeE.Item;
}
_objectReader.Parse(PRs);
}
private void ReadMemberReference()
{
if (this.memberReference == null)
{
this.memberReference = new MemberReference();
}
this.memberReference.Read(this);
this.memberReference.Dump();
ObjectProgress objectProgress = (ObjectProgress)this.stack.Peek();
this.prs.Init();
this.prs.PRidRef = this.objectReader.GetId((long)this.memberReference.idRef);
this.prs.PRparseTypeEnum = InternalParseTypeE.Member;
this.prs.PRmemberValueEnum = InternalMemberValueE.Reference;
if (objectProgress.objectTypeEnum == InternalObjectTypeE.Object)
{
this.prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
this.prs.PRname = objectProgress.name;
this.prs.PRdtType = objectProgress.dtType;
}
else
{
this.prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
}
this.objectReader.Parse(this.prs);
}
private void ReadObjectNull(BinaryHeaderEnum binaryHeaderEnum)
{
if (this.objectNull == null)
{
this.objectNull = new ObjectNull();
}
this.objectNull.Read(this, binaryHeaderEnum);
this.objectNull.Dump();
ObjectProgress objectProgress = (ObjectProgress)this.stack.Peek();
this.prs.Init();
this.prs.PRparseTypeEnum = InternalParseTypeE.Member;
this.prs.PRmemberValueEnum = InternalMemberValueE.Null;
if (objectProgress.objectTypeEnum == InternalObjectTypeE.Object)
{
this.prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
this.prs.PRname = objectProgress.name;
this.prs.PRdtType = objectProgress.dtType;
}
else
{
this.prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
this.prs.PRnullCount = this.objectNull.nullCount;
objectProgress.ArrayCountIncrement(this.objectNull.nullCount - 1);
}
this.objectReader.Parse(this.prs);
}
private void ReadObjectNull(BinaryHeaderEnum binaryHeaderEnum)
{
if (_objectNull == null)
{
_objectNull = new ObjectNull();
}
_objectNull.Read(this, binaryHeaderEnum);
ObjectProgress objectOp = (ObjectProgress)_stack.Peek();
PRs.Init();
PRs._parseTypeEnum = InternalParseTypeE.Member;
PRs._memberValueEnum = InternalMemberValueE.Null;
if (objectOp._objectTypeEnum == InternalObjectTypeE.Object)
{
PRs._memberTypeEnum = InternalMemberTypeE.Field;
PRs._name = objectOp._name;
PRs._dtType = objectOp._dtType;
}
else
{
PRs._memberTypeEnum = InternalMemberTypeE.Item;
PRs._consecutiveNullArrayEntryCount = _objectNull._nullCount;
//only one null position has been incremented by GetNext
//The position needs to be reset for the rest of the nulls
objectOp.ArrayCountIncrement(_objectNull._nullCount - 1);
}
_objectReader.Parse(PRs);
}
private void ReadMemberReference()
{
if (_memberReference == null)
{
_memberReference = new MemberReference();
}
_memberReference.Read(this);
ObjectProgress objectOp = (ObjectProgress)_stack.Peek();
PRs.Init();
PRs._idRef = _objectReader.GetId(_memberReference._idRef);
PRs._parseTypeEnum = InternalParseTypeE.Member;
PRs._memberValueEnum = InternalMemberValueE.Reference;
if (objectOp._objectTypeEnum == InternalObjectTypeE.Object)
{
PRs._memberTypeEnum = InternalMemberTypeE.Field;
PRs._name = objectOp._name;
PRs._dtType = objectOp._dtType;
}
else
{
PRs._memberTypeEnum = InternalMemberTypeE.Item;
}
_objectReader.Parse(PRs);
}
private void PutOp(ObjectProgress op)
{
if (this.opPool == null)
{
this.opPool = new SerStack("opPool");
}
this.opPool.Push(op);
}
private void PutOp(ObjectProgress op)
{
if (this.opPool == null)
{
this.opPool = new SerStack("opPool");
}
this.opPool.Push((object)op);
}
private void PutOp(ObjectProgress op)
{
if (_opPool == null)
{
_opPool = new SerStack("opPool");
}
_opPool.Push(op);
}
private void ReadMemberPrimitiveTyped()
{
SerTrace.Log(this, "ReadObjectPrimitive");
if (memberPrimitiveTyped == null)
{
memberPrimitiveTyped = new MemberPrimitiveTyped();
}
memberPrimitiveTyped.Read(this);
memberPrimitiveTyped.Dump();
prs.PRobjectTypeEnum = InternalObjectTypeE.Object; //Get rid of
ObjectProgress objectOp = (ObjectProgress)stack.Peek();
prs.Init();
prs.PRvarValue = memberPrimitiveTyped.value;
prs.PRkeyDt = Converter.ToComType(memberPrimitiveTyped.primitiveTypeEnum);
prs.PRdtType = Converter.ToType(memberPrimitiveTyped.primitiveTypeEnum);
prs.PRdtTypeCode = memberPrimitiveTyped.primitiveTypeEnum;
if (objectOp == null)
{
// Top level boxed primitive
SerTrace.Log(this, "ReadObjectPrimitive, Non-Nested");
prs.PRparseTypeEnum = InternalParseTypeE.Object;
prs.PRname = "System.Variant";
}
else
{
// Nested in an Object
SerTrace.Log(this, "ReadObjectPrimitive, Nested");
prs.PRparseTypeEnum = InternalParseTypeE.Member;
prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
switch (objectOp.objectTypeEnum)
{
case InternalObjectTypeE.Object:
prs.PRname = objectOp.name;
prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
break;
case InternalObjectTypeE.Array:
prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_ObjectTypeEnum"), ((Enum)objectOp.objectTypeEnum).ToString()));
}
}
objectReader.Parse(prs);
}
private ObjectProgress GetOp()
{
ObjectProgress progress = null;
if ((this.opPool != null) && !this.opPool.IsEmpty())
{
progress = (ObjectProgress)this.opPool.Pop();
progress.Init();
return(progress);
}
return(new ObjectProgress());
}
private ObjectProgress GetOp()
{
ObjectProgress objectProgress;
if (this.opPool != null && !this.opPool.IsEmpty())
{
objectProgress = (ObjectProgress)this.opPool.Pop();
objectProgress.Init();
}
else
{
objectProgress = new ObjectProgress();
}
return(objectProgress);
}
private void ReadMemberPrimitiveTyped()
{
if (_memberPrimitiveTyped == null)
{
_memberPrimitiveTyped = new MemberPrimitiveTyped();
}
_memberPrimitiveTyped.Read(this);
PRs._objectTypeEnum = InternalObjectTypeE.Object; //Get rid of
ObjectProgress objectOp = (ObjectProgress)_stack.Peek();
PRs.Init();
PRs._varValue = _memberPrimitiveTyped._value;
PRs._keyDt = Converter.ToComType(_memberPrimitiveTyped._primitiveTypeEnum);
PRs._dtType = Converter.ToType(_memberPrimitiveTyped._primitiveTypeEnum);
PRs._dtTypeCode = _memberPrimitiveTyped._primitiveTypeEnum;
if (objectOp == null)
{
// Top level boxed primitive
PRs._parseTypeEnum = InternalParseTypeE.Object;
PRs._name = "System.Variant";
}
else
{
// Nested in an Object
PRs._parseTypeEnum = InternalParseTypeE.Member;
PRs._memberValueEnum = InternalMemberValueE.InlineValue;
switch (objectOp._objectTypeEnum)
{
case InternalObjectTypeE.Object:
PRs._name = objectOp._name;
PRs._memberTypeEnum = InternalMemberTypeE.Field;
break;
case InternalObjectTypeE.Array:
PRs._memberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(SR.Format(SR.Serialization_ObjectTypeEnum, objectOp._objectTypeEnum.ToString()));
}
}
_objectReader.Parse(PRs);
}
private ObjectProgress GetOp()
{
ObjectProgress op = null;
if (_opPool != null && !_opPool.IsEmpty())
{
op = (ObjectProgress)_opPool.Pop();
op.Init();
}
else
{
op = new ObjectProgress();
}
return(op);
}
private void ReadMemberPrimitiveTyped()
{
if (this.memberPrimitiveTyped == null)
{
this.memberPrimitiveTyped = new MemberPrimitiveTyped();
}
this.memberPrimitiveTyped.Read(this);
this.memberPrimitiveTyped.Dump();
this.prs.PRobjectTypeEnum = InternalObjectTypeE.Object;
ObjectProgress objectProgress = (ObjectProgress)this.stack.Peek();
this.prs.Init();
this.prs.PRvarValue = this.memberPrimitiveTyped.value;
this.prs.PRkeyDt = Converter.ToComType(this.memberPrimitiveTyped.primitiveTypeEnum);
this.prs.PRdtType = Converter.ToType(this.memberPrimitiveTyped.primitiveTypeEnum);
this.prs.PRdtTypeCode = this.memberPrimitiveTyped.primitiveTypeEnum;
if (objectProgress == null)
{
this.prs.PRparseTypeEnum = InternalParseTypeE.Object;
this.prs.PRname = "System.Variant";
}
else
{
this.prs.PRparseTypeEnum = InternalParseTypeE.Member;
this.prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
switch (objectProgress.objectTypeEnum)
{
case InternalObjectTypeE.Object:
this.prs.PRname = objectProgress.name;
this.prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
break;
case InternalObjectTypeE.Array:
this.prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_ObjectTypeEnum", (object)objectProgress.objectTypeEnum.ToString()));
}
}
this.objectReader.Parse(this.prs);
}
private void ReadObjectWithMap(BinaryObjectWithMap record)
{
BinaryAssemblyInfo assemblyInfo = null;
ObjectProgress op = this.GetOp();
ParseRecord pr = op.pr;
this.stack.Push(op);
if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapAssemId)
{
if (record.assemId < 1)
{
throw new SerializationException(Environment.GetResourceString("Serialization_Assembly", new object[] { record.name }));
}
assemblyInfo = (BinaryAssemblyInfo)this.AssemIdToAssemblyTable[record.assemId];
if (assemblyInfo == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_Assembly", new object[] { record.assemId + " " + record.name }));
}
}
else if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMap)
{
assemblyInfo = this.SystemAssemblyInfo;
}
Type objectType = this.objectReader.GetType(assemblyInfo, record.name);
ObjectMap map = ObjectMap.Create(record.name, objectType, record.memberNames, this.objectReader, record.objectId, assemblyInfo);
this.ObjectMapIdTable[record.objectId] = map;
op.objectTypeEnum = InternalObjectTypeE.Object;
op.binaryTypeEnumA = map.binaryTypeEnumA;
op.typeInformationA = map.typeInformationA;
op.memberLength = op.binaryTypeEnumA.Length;
op.memberNames = map.memberNames;
op.memberTypes = map.memberTypes;
ObjectProgress progress2 = (ObjectProgress)this.stack.PeekPeek();
if ((progress2 == null) || progress2.isInitial)
{
op.name = record.name;
pr.PRparseTypeEnum = InternalParseTypeE.Object;
op.memberValueEnum = InternalMemberValueE.Empty;
}
else
{
pr.PRparseTypeEnum = InternalParseTypeE.Member;
pr.PRmemberValueEnum = InternalMemberValueE.Nested;
op.memberValueEnum = InternalMemberValueE.Nested;
switch (progress2.objectTypeEnum)
{
case InternalObjectTypeE.Object:
pr.PRname = progress2.name;
pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
op.memberTypeEnum = InternalMemberTypeE.Field;
goto Label_0213;
case InternalObjectTypeE.Array:
pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
op.memberTypeEnum = InternalMemberTypeE.Field;
goto Label_0213;
}
throw new SerializationException(Environment.GetResourceString("Serialization_ObjectTypeEnum", new object[] { progress2.objectTypeEnum.ToString() }));
}
Label_0213:
pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
pr.PRobjectId = this.objectReader.GetId((long)record.objectId);
pr.PRobjectInfo = map.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData);
if (pr.PRobjectId == this.topId)
{
pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
}
pr.PRkeyDt = record.name;
pr.PRdtType = map.objectType;
pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
this.objectReader.Parse(pr);
}
private void ReadArray(BinaryHeaderEnum binaryHeaderEnum)
{
BinaryAssemblyInfo assemblyInfo = null;
BinaryArray record = new BinaryArray(binaryHeaderEnum);
record.Read(this);
if (record._binaryTypeEnum == BinaryTypeEnum.ObjectUser)
{
if (record._assemId < 1)
{
throw new SerializationException(SR.Format(SR.Serialization_AssemblyId, record._typeInformation));
}
assemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[record._assemId];
}
else
{
assemblyInfo = SystemAssemblyInfo; //Urt assembly
}
ObjectProgress op = GetOp();
ParseRecord pr = op._pr;
op._objectTypeEnum = InternalObjectTypeE.Array;
op._binaryTypeEnum = record._binaryTypeEnum;
op._typeInformation = record._typeInformation;
ObjectProgress objectOp = (ObjectProgress)_stack.PeekPeek();
if ((objectOp == null) || (record._objectId > 0))
{
// Non-Nested Object
op._name = "System.Array";
pr._parseTypeEnum = InternalParseTypeE.Object;
op._memberValueEnum = InternalMemberValueE.Empty;
}
else
{
// Nested Object
pr._parseTypeEnum = InternalParseTypeE.Member;
pr._memberValueEnum = InternalMemberValueE.Nested;
op._memberValueEnum = InternalMemberValueE.Nested;
switch (objectOp._objectTypeEnum)
{
case InternalObjectTypeE.Object:
pr._name = objectOp._name;
pr._memberTypeEnum = InternalMemberTypeE.Field;
op._memberTypeEnum = InternalMemberTypeE.Field;
pr._keyDt = objectOp._name;
pr._dtType = objectOp._dtType;
break;
case InternalObjectTypeE.Array:
pr._memberTypeEnum = InternalMemberTypeE.Item;
op._memberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(SR.Format(SR.Serialization_ObjectTypeEnum, objectOp._objectTypeEnum.ToString()));
}
}
pr._objectId = _objectReader.GetId(record._objectId);
if (pr._objectId == _topId)
{
pr._objectPositionEnum = InternalObjectPositionE.Top;
}
else if ((_headerId > 0) && (pr._objectId == _headerId))
{
pr._objectPositionEnum = InternalObjectPositionE.Headers; // Headers are an array of header objects
}
else
{
pr._objectPositionEnum = InternalObjectPositionE.Child;
}
pr._objectTypeEnum = InternalObjectTypeE.Array;
BinaryTypeConverter.TypeFromInfo(record._binaryTypeEnum, record._typeInformation, _objectReader, assemblyInfo,
out pr._arrayElementTypeCode, out pr._arrayElementTypeString,
out pr._arrayElementType, out pr._isArrayVariant);
pr._dtTypeCode = InternalPrimitiveTypeE.Invalid;
pr._rank = record._rank;
pr._lengthA = record._lengthA;
pr._lowerBoundA = record._lowerBoundA;
bool isPrimitiveArray = false;
switch (record._binaryArrayTypeEnum)
{
case BinaryArrayTypeEnum.Single:
case BinaryArrayTypeEnum.SingleOffset:
op._numItems = record._lengthA[0];
pr._arrayTypeEnum = InternalArrayTypeE.Single;
if (Converter.IsWriteAsByteArray(pr._arrayElementTypeCode) &&
(record._lowerBoundA[0] == 0))
{
isPrimitiveArray = true;
ReadArrayAsBytes(pr);
}
break;
case BinaryArrayTypeEnum.Jagged:
case BinaryArrayTypeEnum.JaggedOffset:
op._numItems = record._lengthA[0];
pr._arrayTypeEnum = InternalArrayTypeE.Jagged;
break;
case BinaryArrayTypeEnum.Rectangular:
case BinaryArrayTypeEnum.RectangularOffset:
int arrayLength = 1;
for (int i = 0; i < record._rank; i++)
{
arrayLength = arrayLength * record._lengthA[i];
}
op._numItems = arrayLength;
pr._arrayTypeEnum = InternalArrayTypeE.Rectangular;
break;
default:
throw new SerializationException(SR.Format(SR.Serialization_ArrayType, record._binaryArrayTypeEnum.ToString()));
}
if (!isPrimitiveArray)
{
_stack.Push(op);
}
else
{
PutOp(op);
}
_objectReader.Parse(pr);
if (isPrimitiveArray)
{
pr._parseTypeEnum = InternalParseTypeE.ObjectEnd;
_objectReader.Parse(pr);
}
}
// Parse the input
// Reads each record from the input stream. If the record is a primitive type (A number)
// then it doesn't have a BinaryHeaderEnum byte. For this case the expected type
// has been previously set to Primitive
internal void Run()
{
try
{
bool isLoop = true;
ReadBegin();
ReadSerializationHeaderRecord();
while (isLoop)
{
BinaryHeaderEnum binaryHeaderEnum = BinaryHeaderEnum.Object;
switch (_expectedType)
{
case BinaryTypeEnum.ObjectUrt:
case BinaryTypeEnum.ObjectUser:
case BinaryTypeEnum.String:
case BinaryTypeEnum.Object:
case BinaryTypeEnum.ObjectArray:
case BinaryTypeEnum.StringArray:
case BinaryTypeEnum.PrimitiveArray:
byte inByte = _dataReader.ReadByte();
binaryHeaderEnum = (BinaryHeaderEnum)inByte;
switch (binaryHeaderEnum)
{
case BinaryHeaderEnum.Assembly:
case BinaryHeaderEnum.CrossAppDomainAssembly:
ReadAssembly(binaryHeaderEnum);
break;
case BinaryHeaderEnum.Object:
ReadObject();
break;
case BinaryHeaderEnum.CrossAppDomainMap:
ReadCrossAppDomainMap();
break;
case BinaryHeaderEnum.ObjectWithMap:
case BinaryHeaderEnum.ObjectWithMapAssemId:
ReadObjectWithMap(binaryHeaderEnum);
break;
case BinaryHeaderEnum.ObjectWithMapTyped:
case BinaryHeaderEnum.ObjectWithMapTypedAssemId:
ReadObjectWithMapTyped(binaryHeaderEnum);
break;
case BinaryHeaderEnum.ObjectString:
case BinaryHeaderEnum.CrossAppDomainString:
ReadObjectString(binaryHeaderEnum);
break;
case BinaryHeaderEnum.Array:
case BinaryHeaderEnum.ArraySinglePrimitive:
case BinaryHeaderEnum.ArraySingleObject:
case BinaryHeaderEnum.ArraySingleString:
ReadArray(binaryHeaderEnum);
break;
case BinaryHeaderEnum.MemberPrimitiveTyped:
ReadMemberPrimitiveTyped();
break;
case BinaryHeaderEnum.MemberReference:
ReadMemberReference();
break;
case BinaryHeaderEnum.ObjectNull:
case BinaryHeaderEnum.ObjectNullMultiple256:
case BinaryHeaderEnum.ObjectNullMultiple:
ReadObjectNull(binaryHeaderEnum);
break;
case BinaryHeaderEnum.MessageEnd:
isLoop = false;
ReadMessageEnd();
ReadEnd();
break;
default:
throw new SerializationException(SR.Format(SR.Serialization_BinaryHeader, inByte));
}
break;
case BinaryTypeEnum.Primitive:
ReadMemberPrimitiveUnTyped();
break;
default:
throw new SerializationException(SR.Serialization_TypeExpected);
}
// If an assembly is encountered, don't advance
// object Progress,
if (binaryHeaderEnum != BinaryHeaderEnum.Assembly)
{
// End of parse loop.
bool isData = false;
// Set up loop for next iteration.
// If this is an object, and the end of object has been reached, then parse object end.
while (!isData)
{
ObjectProgress op = (ObjectProgress)_stack.Peek();
if (op == null)
{
// No more object on stack, then the next record is a top level object
_expectedType = BinaryTypeEnum.ObjectUrt;
_expectedTypeInformation = null;
isData = true;
}
else
{
// Find out what record is expected next
isData = op.GetNext(out op._expectedType, out op._expectedTypeInformation);
_expectedType = op._expectedType;
_expectedTypeInformation = op._expectedTypeInformation;
if (!isData)
{
// No record is expected next, this is the end of an object or array
PRs.Init();
if (op._memberValueEnum == InternalMemberValueE.Nested)
{
// Nested object
PRs._parseTypeEnum = InternalParseTypeE.MemberEnd;
PRs._memberTypeEnum = op._memberTypeEnum;
PRs._memberValueEnum = op._memberValueEnum;
_objectReader.Parse(PRs);
}
else
{
// Top level object
PRs._parseTypeEnum = InternalParseTypeE.ObjectEnd;
PRs._memberTypeEnum = op._memberTypeEnum;
PRs._memberValueEnum = op._memberValueEnum;
_objectReader.Parse(PRs);
}
_stack.Pop();
PutOp(op);
}
}
}
}
}
}
catch (EndOfStreamException)
{
// EOF should never be thrown since there is a MessageEnd record to stop parsing
throw new SerializationException(SR.Serialization_StreamEnd);
}
}
private void ReadObjectString(BinaryHeaderEnum binaryHeaderEnum)
{
if (_objectString == null)
{
_objectString = new BinaryObjectString();
}
if (binaryHeaderEnum == BinaryHeaderEnum.ObjectString)
{
_objectString.Read(this);
}
else
{
if (_crossAppDomainString == null)
{
_crossAppDomainString = new BinaryCrossAppDomainString();
}
_crossAppDomainString.Read(this);
_objectString._value = _objectReader.CrossAppDomainArray(_crossAppDomainString._value) as string;
if (_objectString._value == null)
{
throw new SerializationException(SR.Format(SR.Serialization_CrossAppDomainError, "String", _crossAppDomainString._value));
}
_objectString._objectId = _crossAppDomainString._objectId;
}
PRs.Init();
PRs._parseTypeEnum = InternalParseTypeE.Object;
PRs._objectId = _objectReader.GetId(_objectString._objectId);
if (PRs._objectId == _topId)
{
PRs._objectPositionEnum = InternalObjectPositionE.Top;
}
PRs._objectTypeEnum = InternalObjectTypeE.Object;
ObjectProgress objectOp = (ObjectProgress)_stack.Peek();
PRs._value = _objectString._value;
PRs._keyDt = "System.String";
PRs._dtType = Converter.s_typeofString;
PRs._dtTypeCode = InternalPrimitiveTypeE.Invalid;
PRs._varValue = _objectString._value; //Need to set it because ObjectReader is picking up value from variant, not pr.PRvalue
if (objectOp == null)
{
// Top level String
PRs._parseTypeEnum = InternalParseTypeE.Object;
PRs._name = "System.String";
}
else
{
// Nested in an Object
PRs._parseTypeEnum = InternalParseTypeE.Member;
PRs._memberValueEnum = InternalMemberValueE.InlineValue;
switch (objectOp._objectTypeEnum)
{
case InternalObjectTypeE.Object:
PRs._name = objectOp._name;
PRs._memberTypeEnum = InternalMemberTypeE.Field;
break;
case InternalObjectTypeE.Array:
PRs._memberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(SR.Format(SR.Serialization_ObjectTypeEnum, objectOp._objectTypeEnum.ToString()));
}
}
_objectReader.Parse(PRs);
}
private void ReadObjectWithMapTyped(BinaryObjectWithMapTyped record)
{
BinaryAssemblyInfo assemblyInfo = null;
ObjectProgress op = GetOp();
ParseRecord pr = op._pr;
_stack.Push(op);
if (record._binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTypedAssemId)
{
if (record._assemId < 1)
{
throw new SerializationException(SR.Format(SR.Serialization_AssemblyId, record._name));
}
assemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[record._assemId];
if (assemblyInfo == null)
{
throw new SerializationException(SR.Format(SR.Serialization_AssemblyId, record._assemId + " " + record._name));
}
}
else if (record._binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTyped)
{
assemblyInfo = SystemAssemblyInfo; // Urt assembly
}
ObjectMap objectMap = ObjectMap.Create(record._name, record._memberNames, record._binaryTypeEnumA, record._typeInformationA, record._memberAssemIds, _objectReader, record._objectId, assemblyInfo, AssemIdToAssemblyTable);
ObjectMapIdTable[record._objectId] = objectMap;
op._objectTypeEnum = InternalObjectTypeE.Object;
op._binaryTypeEnumA = objectMap._binaryTypeEnumA;
op._typeInformationA = objectMap._typeInformationA;
op._memberLength = op._binaryTypeEnumA.Length;
op._memberNames = objectMap._memberNames;
op._memberTypes = objectMap._memberTypes;
ObjectProgress objectOp = (ObjectProgress)_stack.PeekPeek();
if ((objectOp == null) || (objectOp._isInitial))
{
// Non-Nested Object
op._name = record._name;
pr._parseTypeEnum = InternalParseTypeE.Object;
op._memberValueEnum = InternalMemberValueE.Empty;
}
else
{
// Nested Object
pr._parseTypeEnum = InternalParseTypeE.Member;
pr._memberValueEnum = InternalMemberValueE.Nested;
op._memberValueEnum = InternalMemberValueE.Nested;
switch (objectOp._objectTypeEnum)
{
case InternalObjectTypeE.Object:
pr._name = objectOp._name;
pr._memberTypeEnum = InternalMemberTypeE.Field;
op._memberTypeEnum = InternalMemberTypeE.Field;
break;
case InternalObjectTypeE.Array:
pr._memberTypeEnum = InternalMemberTypeE.Item;
op._memberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(SR.Format(SR.Serialization_ObjectTypeEnum, objectOp._objectTypeEnum.ToString()));
}
}
pr._objectTypeEnum = InternalObjectTypeE.Object;
pr._objectInfo = objectMap.CreateObjectInfo(ref pr._si, ref pr._memberData);
pr._objectId = _objectReader.GetId(record._objectId);
if (pr._objectId == _topId)
{
pr._objectPositionEnum = InternalObjectPositionE.Top;
}
pr._keyDt = record._name;
pr._dtType = objectMap._objectType;
pr._dtTypeCode = InternalPrimitiveTypeE.Invalid;
_objectReader.Parse(pr);
}
private void ReadObject()
{
if (_binaryObject == null)
{
_binaryObject = new BinaryObject();
}
_binaryObject.Read(this);
ObjectMap objectMap = (ObjectMap)ObjectMapIdTable[_binaryObject._mapId];
if (objectMap == null)
{
throw new SerializationException(SR.Format(SR.Serialization_Map, _binaryObject._mapId));
}
ObjectProgress op = GetOp();
ParseRecord pr = op._pr;
_stack.Push(op);
op._objectTypeEnum = InternalObjectTypeE.Object;
op._binaryTypeEnumA = objectMap._binaryTypeEnumA;
op._memberNames = objectMap._memberNames;
op._memberTypes = objectMap._memberTypes;
op._typeInformationA = objectMap._typeInformationA;
op._memberLength = op._binaryTypeEnumA.Length;
ObjectProgress objectOp = (ObjectProgress)_stack.PeekPeek();
if ((objectOp == null) || (objectOp._isInitial))
{
// Non-Nested Object
op._name = objectMap._objectName;
pr._parseTypeEnum = InternalParseTypeE.Object;
op._memberValueEnum = InternalMemberValueE.Empty;
}
else
{
// Nested Object
pr._parseTypeEnum = InternalParseTypeE.Member;
pr._memberValueEnum = InternalMemberValueE.Nested;
op._memberValueEnum = InternalMemberValueE.Nested;
switch (objectOp._objectTypeEnum)
{
case InternalObjectTypeE.Object:
pr._name = objectOp._name;
pr._memberTypeEnum = InternalMemberTypeE.Field;
op._memberTypeEnum = InternalMemberTypeE.Field;
break;
case InternalObjectTypeE.Array:
pr._memberTypeEnum = InternalMemberTypeE.Item;
op._memberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(SR.Format(SR.Serialization_Map, objectOp._objectTypeEnum.ToString()));
}
}
pr._objectId = _objectReader.GetId(_binaryObject._objectId);
pr._objectInfo = objectMap.CreateObjectInfo(ref pr._si, ref pr._memberData);
if (pr._objectId == _topId)
{
pr._objectPositionEnum = InternalObjectPositionE.Top;
}
pr._objectTypeEnum = InternalObjectTypeE.Object;
pr._keyDt = objectMap._objectName;
pr._dtType = objectMap._objectType;
pr._dtTypeCode = InternalPrimitiveTypeE.Invalid;
_objectReader.Parse(pr);
}
internal void Run()
{
try
{
bool flag = true;
this.ReadBegin();
this.ReadSerializationHeaderRecord();
while (flag)
{
byte num;
BinaryHeaderEnum binaryHeaderEnum = BinaryHeaderEnum.Object;
switch (this.expectedType)
{
case BinaryTypeEnum.Primitive:
this.ReadMemberPrimitiveUnTyped();
goto Label_0177;
case BinaryTypeEnum.String:
case BinaryTypeEnum.Object:
case BinaryTypeEnum.ObjectUrt:
case BinaryTypeEnum.ObjectUser:
case BinaryTypeEnum.ObjectArray:
case BinaryTypeEnum.StringArray:
case BinaryTypeEnum.PrimitiveArray:
num = this.dataReader.ReadByte();
binaryHeaderEnum = (BinaryHeaderEnum)num;
switch (binaryHeaderEnum)
{
case BinaryHeaderEnum.Object:
goto Label_00C9;
case BinaryHeaderEnum.ObjectWithMap:
case BinaryHeaderEnum.ObjectWithMapAssemId:
goto Label_00DF;
case BinaryHeaderEnum.ObjectWithMapTyped:
case BinaryHeaderEnum.ObjectWithMapTypedAssemId:
goto Label_00EB;
case BinaryHeaderEnum.ObjectString:
case BinaryHeaderEnum.CrossAppDomainString:
goto Label_0100;
case BinaryHeaderEnum.Array:
case BinaryHeaderEnum.ArraySinglePrimitive:
case BinaryHeaderEnum.ArraySingleObject:
case BinaryHeaderEnum.ArraySingleString:
goto Label_0109;
case BinaryHeaderEnum.MemberPrimitiveTyped:
goto Label_0112;
case BinaryHeaderEnum.MemberReference:
goto Label_011A;
case BinaryHeaderEnum.ObjectNull:
case BinaryHeaderEnum.ObjectNullMultiple256:
case BinaryHeaderEnum.ObjectNullMultiple:
goto Label_0122;
case BinaryHeaderEnum.MessageEnd:
goto Label_012B;
case BinaryHeaderEnum.CrossAppDomainMap:
goto Label_00D4;
case BinaryHeaderEnum.MethodCall:
case BinaryHeaderEnum.MethodReturn:
goto Label_00F7;
}
goto Label_013B;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_TypeExpected"));
}
this.ReadAssembly(binaryHeaderEnum);
goto Label_0177;
Label_00C9:
this.ReadObject();
goto Label_0177;
Label_00D4:
this.ReadCrossAppDomainMap();
goto Label_0177;
Label_00DF:
this.ReadObjectWithMap(binaryHeaderEnum);
goto Label_0177;
Label_00EB:
this.ReadObjectWithMapTyped(binaryHeaderEnum);
goto Label_0177;
Label_00F7:
this.ReadMethodObject(binaryHeaderEnum);
goto Label_0177;
Label_0100:
this.ReadObjectString(binaryHeaderEnum);
goto Label_0177;
Label_0109:
this.ReadArray(binaryHeaderEnum);
goto Label_0177;
Label_0112:
this.ReadMemberPrimitiveTyped();
goto Label_0177;
Label_011A:
this.ReadMemberReference();
goto Label_0177;
Label_0122:
this.ReadObjectNull(binaryHeaderEnum);
goto Label_0177;
Label_012B:
flag = false;
this.ReadMessageEnd();
this.ReadEnd();
goto Label_0177;
Label_013B :;
throw new SerializationException(Environment.GetResourceString("Serialization_BinaryHeader", new object[] { num }));
Label_0177:
if (binaryHeaderEnum != BinaryHeaderEnum.Assembly)
{
bool next = false;
while (!next)
{
ObjectProgress op = (ObjectProgress)this.stack.Peek();
if (op == null)
{
this.expectedType = BinaryTypeEnum.ObjectUrt;
this.expectedTypeInformation = null;
next = true;
}
else
{
next = op.GetNext(out op.expectedType, out op.expectedTypeInformation);
this.expectedType = op.expectedType;
this.expectedTypeInformation = op.expectedTypeInformation;
if (!next)
{
this.prs.Init();
if (op.memberValueEnum == InternalMemberValueE.Nested)
{
this.prs.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
this.prs.PRmemberTypeEnum = op.memberTypeEnum;
this.prs.PRmemberValueEnum = op.memberValueEnum;
this.objectReader.Parse(this.prs);
}
else
{
this.prs.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
this.prs.PRmemberTypeEnum = op.memberTypeEnum;
this.prs.PRmemberValueEnum = op.memberValueEnum;
this.objectReader.Parse(this.prs);
}
this.stack.Pop();
this.PutOp(op);
}
}
}
}
}
}
catch (EndOfStreamException)
{
throw new SerializationException(Environment.GetResourceString("Serialization_StreamEnd"));
}
}
private void ReadObject()
{
if (this.binaryObject == null)
{
this.binaryObject = new BinaryObject();
}
this.binaryObject.Read(this);
this.binaryObject.Dump();
ObjectMap objectMap = (ObjectMap)this.ObjectMapIdTable[this.binaryObject.mapId];
if (objectMap == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_Map", (object)this.binaryObject.mapId));
}
ObjectProgress op = this.GetOp();
ParseRecord pr = op.pr;
this.stack.Push((object)op);
op.objectTypeEnum = InternalObjectTypeE.Object;
op.binaryTypeEnumA = objectMap.binaryTypeEnumA;
op.memberNames = objectMap.memberNames;
op.memberTypes = objectMap.memberTypes;
op.typeInformationA = objectMap.typeInformationA;
ObjectProgress objectProgress1 = op;
int length = objectProgress1.binaryTypeEnumA.Length;
objectProgress1.memberLength = length;
ObjectProgress objectProgress2 = (ObjectProgress)this.stack.PeekPeek();
if (objectProgress2 == null || objectProgress2.isInitial)
{
op.name = objectMap.objectName;
pr.PRparseTypeEnum = InternalParseTypeE.Object;
op.memberValueEnum = InternalMemberValueE.Empty;
}
else
{
pr.PRparseTypeEnum = InternalParseTypeE.Member;
pr.PRmemberValueEnum = InternalMemberValueE.Nested;
op.memberValueEnum = InternalMemberValueE.Nested;
switch (objectProgress2.objectTypeEnum)
{
case InternalObjectTypeE.Object:
pr.PRname = objectProgress2.name;
pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
op.memberTypeEnum = InternalMemberTypeE.Field;
break;
case InternalObjectTypeE.Array:
pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
op.memberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_Map", (object)objectProgress2.objectTypeEnum.ToString()));
}
}
pr.PRobjectId = this.objectReader.GetId((long)this.binaryObject.objectId);
pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData);
if (pr.PRobjectId == this.topId)
{
pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
}
pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
pr.PRkeyDt = objectMap.objectName;
pr.PRdtType = objectMap.objectType;
pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
this.objectReader.Parse(pr);
}
private void ReadObjectWithMapTyped(BinaryObjectWithMapTyped record)
{
BinaryAssemblyInfo assemblyInfo = (BinaryAssemblyInfo)null;
ObjectProgress op = this.GetOp();
ParseRecord pr = op.pr;
this.stack.Push((object)op);
if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTypedAssemId)
{
if (record.assemId < 1)
{
throw new SerializationException(Environment.GetResourceString("Serialization_AssemblyId", (object)record.name));
}
assemblyInfo = (BinaryAssemblyInfo)this.AssemIdToAssemblyTable[record.assemId];
if (assemblyInfo == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_AssemblyId", (object)(record.assemId.ToString() + " " + record.name)));
}
}
else if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTyped)
{
assemblyInfo = this.SystemAssemblyInfo;
}
ObjectMap objectMap = ObjectMap.Create(record.name, record.memberNames, record.binaryTypeEnumA, record.typeInformationA, record.memberAssemIds, this.objectReader, record.objectId, assemblyInfo, this.AssemIdToAssemblyTable);
this.ObjectMapIdTable[record.objectId] = (object)objectMap;
op.objectTypeEnum = InternalObjectTypeE.Object;
op.binaryTypeEnumA = objectMap.binaryTypeEnumA;
op.typeInformationA = objectMap.typeInformationA;
ObjectProgress objectProgress1 = op;
int length = objectProgress1.binaryTypeEnumA.Length;
objectProgress1.memberLength = length;
op.memberNames = objectMap.memberNames;
op.memberTypes = objectMap.memberTypes;
ObjectProgress objectProgress2 = (ObjectProgress)this.stack.PeekPeek();
if (objectProgress2 == null || objectProgress2.isInitial)
{
op.name = record.name;
pr.PRparseTypeEnum = InternalParseTypeE.Object;
op.memberValueEnum = InternalMemberValueE.Empty;
}
else
{
pr.PRparseTypeEnum = InternalParseTypeE.Member;
pr.PRmemberValueEnum = InternalMemberValueE.Nested;
op.memberValueEnum = InternalMemberValueE.Nested;
switch (objectProgress2.objectTypeEnum)
{
case InternalObjectTypeE.Object:
pr.PRname = objectProgress2.name;
pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
op.memberTypeEnum = InternalMemberTypeE.Field;
break;
case InternalObjectTypeE.Array:
pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
op.memberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_ObjectTypeEnum", (object)objectProgress2.objectTypeEnum.ToString()));
}
}
pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData);
pr.PRobjectId = this.objectReader.GetId((long)record.objectId);
if (pr.PRobjectId == this.topId)
{
pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
}
pr.PRkeyDt = record.name;
pr.PRdtType = objectMap.objectType;
pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
this.objectReader.Parse(pr);
}
private void ReadArray(BinaryHeaderEnum binaryHeaderEnum)
{
BinaryAssemblyInfo assemblyInfo = null;
BinaryArray array = new BinaryArray(binaryHeaderEnum);
array.Read(this);
if (array.binaryTypeEnum == BinaryTypeEnum.ObjectUser)
{
if (array.assemId < 1)
{
throw new SerializationException(Environment.GetResourceString("Serialization_AssemblyId", new object[] { array.typeInformation }));
}
assemblyInfo = (BinaryAssemblyInfo)this.AssemIdToAssemblyTable[array.assemId];
}
else
{
assemblyInfo = this.SystemAssemblyInfo;
}
ObjectProgress op = this.GetOp();
ParseRecord pr = op.pr;
op.objectTypeEnum = InternalObjectTypeE.Array;
op.binaryTypeEnum = array.binaryTypeEnum;
op.typeInformation = array.typeInformation;
ObjectProgress progress2 = (ObjectProgress)this.stack.PeekPeek();
if ((progress2 == null) || (array.objectId > 0))
{
op.name = "System.Array";
pr.PRparseTypeEnum = InternalParseTypeE.Object;
op.memberValueEnum = InternalMemberValueE.Empty;
}
else
{
pr.PRparseTypeEnum = InternalParseTypeE.Member;
pr.PRmemberValueEnum = InternalMemberValueE.Nested;
op.memberValueEnum = InternalMemberValueE.Nested;
switch (progress2.objectTypeEnum)
{
case InternalObjectTypeE.Object:
pr.PRname = progress2.name;
pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
op.memberTypeEnum = InternalMemberTypeE.Field;
pr.PRkeyDt = progress2.name;
pr.PRdtType = progress2.dtType;
goto Label_0177;
case InternalObjectTypeE.Array:
pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
op.memberTypeEnum = InternalMemberTypeE.Item;
goto Label_0177;
}
throw new SerializationException(Environment.GetResourceString("Serialization_ObjectTypeEnum", new object[] { progress2.objectTypeEnum.ToString() }));
}
Label_0177:
pr.PRobjectId = this.objectReader.GetId((long)array.objectId);
if (pr.PRobjectId == this.topId)
{
pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
}
else if ((this.headerId > 0L) && (pr.PRobjectId == this.headerId))
{
pr.PRobjectPositionEnum = InternalObjectPositionE.Headers;
}
else
{
pr.PRobjectPositionEnum = InternalObjectPositionE.Child;
}
pr.PRobjectTypeEnum = InternalObjectTypeE.Array;
BinaryConverter.TypeFromInfo(array.binaryTypeEnum, array.typeInformation, this.objectReader, assemblyInfo, out pr.PRarrayElementTypeCode, out pr.PRarrayElementTypeString, out pr.PRarrayElementType, out pr.PRisArrayVariant);
pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
pr.PRrank = array.rank;
pr.PRlengthA = array.lengthA;
pr.PRlowerBoundA = array.lowerBoundA;
bool flag = false;
switch (array.binaryArrayTypeEnum)
{
case BinaryArrayTypeEnum.Single:
case BinaryArrayTypeEnum.SingleOffset:
op.numItems = array.lengthA[0];
pr.PRarrayTypeEnum = InternalArrayTypeE.Single;
if (Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode) && (array.lowerBoundA[0] == 0))
{
flag = true;
this.ReadArrayAsBytes(pr);
}
break;
case BinaryArrayTypeEnum.Jagged:
case BinaryArrayTypeEnum.JaggedOffset:
op.numItems = array.lengthA[0];
pr.PRarrayTypeEnum = InternalArrayTypeE.Jagged;
break;
case BinaryArrayTypeEnum.Rectangular:
case BinaryArrayTypeEnum.RectangularOffset:
{
int num = 1;
for (int i = 0; i < array.rank; i++)
{
num *= array.lengthA[i];
}
op.numItems = num;
pr.PRarrayTypeEnum = InternalArrayTypeE.Rectangular;
break;
}
default:
throw new SerializationException(Environment.GetResourceString("Serialization_ArrayType", new object[] { array.binaryArrayTypeEnum.ToString() }));
}
if (!flag)
{
this.stack.Push(op);
}
else
{
this.PutOp(op);
}
this.objectReader.Parse(pr);
if (flag)
{
pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
this.objectReader.Parse(pr);
}
}
private void ReadObjectString(BinaryHeaderEnum binaryHeaderEnum)
{
if (this.objectString == null)
{
this.objectString = new BinaryObjectString();
}
if (binaryHeaderEnum == BinaryHeaderEnum.ObjectString)
{
this.objectString.Read(this);
this.objectString.Dump();
}
else
{
if (this.crossAppDomainString == null)
{
this.crossAppDomainString = new BinaryCrossAppDomainString();
}
this.crossAppDomainString.Read(this);
this.crossAppDomainString.Dump();
this.objectString.value = this.objectReader.CrossAppDomainArray(this.crossAppDomainString.value) as string;
if (this.objectString.value == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_CrossAppDomainError", (object)"String", (object)this.crossAppDomainString.value));
}
this.objectString.objectId = this.crossAppDomainString.objectId;
}
this.prs.Init();
this.prs.PRparseTypeEnum = InternalParseTypeE.Object;
this.prs.PRobjectId = this.objectReader.GetId((long)this.objectString.objectId);
if (this.prs.PRobjectId == this.topId)
{
this.prs.PRobjectPositionEnum = InternalObjectPositionE.Top;
}
this.prs.PRobjectTypeEnum = InternalObjectTypeE.Object;
ObjectProgress objectProgress = (ObjectProgress)this.stack.Peek();
this.prs.PRvalue = this.objectString.value;
this.prs.PRkeyDt = "System.String";
this.prs.PRdtType = Converter.typeofString;
this.prs.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
this.prs.PRvarValue = (object)this.objectString.value;
if (objectProgress == null)
{
this.prs.PRparseTypeEnum = InternalParseTypeE.Object;
this.prs.PRname = "System.String";
}
else
{
this.prs.PRparseTypeEnum = InternalParseTypeE.Member;
this.prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
switch (objectProgress.objectTypeEnum)
{
case InternalObjectTypeE.Object:
this.prs.PRname = objectProgress.name;
this.prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
break;
case InternalObjectTypeE.Array:
this.prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_ObjectTypeEnum", (object)objectProgress.objectTypeEnum.ToString()));
}
}
this.objectReader.Parse(this.prs);
}
private void ReadArray(BinaryHeaderEnum binaryHeaderEnum)
{
BinaryArray binaryArray = new BinaryArray(binaryHeaderEnum);
binaryArray.Read(this);
BinaryAssemblyInfo assemblyInfo;
if (binaryArray.binaryTypeEnum == BinaryTypeEnum.ObjectUser)
{
if (binaryArray.assemId < 1)
{
throw new SerializationException(Environment.GetResourceString("Serialization_AssemblyId", binaryArray.typeInformation));
}
assemblyInfo = (BinaryAssemblyInfo)this.AssemIdToAssemblyTable[binaryArray.assemId];
}
else
{
assemblyInfo = this.SystemAssemblyInfo;
}
ObjectProgress op = this.GetOp();
ParseRecord pr = op.pr;
op.objectTypeEnum = InternalObjectTypeE.Array;
op.binaryTypeEnum = binaryArray.binaryTypeEnum;
op.typeInformation = binaryArray.typeInformation;
ObjectProgress objectProgress = (ObjectProgress)this.stack.PeekPeek();
if (objectProgress == null || binaryArray.objectId > 0)
{
op.name = "System.Array";
pr.PRparseTypeEnum = InternalParseTypeE.Object;
op.memberValueEnum = InternalMemberValueE.Empty;
}
else
{
pr.PRparseTypeEnum = InternalParseTypeE.Member;
pr.PRmemberValueEnum = InternalMemberValueE.Nested;
op.memberValueEnum = InternalMemberValueE.Nested;
switch (objectProgress.objectTypeEnum)
{
case InternalObjectTypeE.Object:
pr.PRname = objectProgress.name;
pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
op.memberTypeEnum = InternalMemberTypeE.Field;
pr.PRkeyDt = objectProgress.name;
pr.PRdtType = objectProgress.dtType;
break;
case InternalObjectTypeE.Array:
pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
op.memberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_ObjectTypeEnum", (object)objectProgress.objectTypeEnum.ToString()));
}
}
pr.PRobjectId = this.objectReader.GetId((long)binaryArray.objectId);
pr.PRobjectPositionEnum = pr.PRobjectId != this.topId ? (this.headerId <= 0L || pr.PRobjectId != this.headerId ? InternalObjectPositionE.Child : InternalObjectPositionE.Headers) : InternalObjectPositionE.Top;
pr.PRobjectTypeEnum = InternalObjectTypeE.Array;
BinaryConverter.TypeFromInfo(binaryArray.binaryTypeEnum, binaryArray.typeInformation, this.objectReader, assemblyInfo, out pr.PRarrayElementTypeCode, out pr.PRarrayElementTypeString, out pr.PRarrayElementType, out pr.PRisArrayVariant);
pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
pr.PRrank = binaryArray.rank;
pr.PRlengthA = binaryArray.lengthA;
pr.PRlowerBoundA = binaryArray.lowerBoundA;
bool flag = false;
switch (binaryArray.binaryArrayTypeEnum)
{
case BinaryArrayTypeEnum.Single:
case BinaryArrayTypeEnum.SingleOffset:
op.numItems = binaryArray.lengthA[0];
pr.PRarrayTypeEnum = InternalArrayTypeE.Single;
if (Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode) && binaryArray.lowerBoundA[0] == 0)
{
flag = true;
this.ReadArrayAsBytes(pr);
break;
}
break;
case BinaryArrayTypeEnum.Jagged:
case BinaryArrayTypeEnum.JaggedOffset:
op.numItems = binaryArray.lengthA[0];
pr.PRarrayTypeEnum = InternalArrayTypeE.Jagged;
break;
case BinaryArrayTypeEnum.Rectangular:
case BinaryArrayTypeEnum.RectangularOffset:
int num = 1;
for (int index = 0; index < binaryArray.rank; ++index)
{
num *= binaryArray.lengthA[index];
}
op.numItems = num;
pr.PRarrayTypeEnum = InternalArrayTypeE.Rectangular;
break;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_ArrayType", (object)binaryArray.binaryArrayTypeEnum.ToString()));
}
if (!flag)
{
this.stack.Push((object)op);
}
else
{
this.PutOp(op);
}
this.objectReader.Parse(pr);
if (!flag)
{
return;
}
pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
this.objectReader.Parse(pr);
}
private ObjectProgress GetOp()
{
ObjectProgress op = null;
if (_opPool != null && !_opPool.IsEmpty())
{
op = (ObjectProgress)_opPool.Pop();
op.Init();
}
else
{
op = new ObjectProgress();
}
return op;
}
internal void Run()
{
try
{
bool flag1 = true;
this.ReadBegin();
this.ReadSerializationHeaderRecord();
while (flag1)
{
BinaryHeaderEnum binaryHeaderEnum = BinaryHeaderEnum.Object;
switch (this.expectedType)
{
case BinaryTypeEnum.Primitive:
this.ReadMemberPrimitiveUnTyped();
break;
case BinaryTypeEnum.String:
case BinaryTypeEnum.Object:
case BinaryTypeEnum.ObjectUrt:
case BinaryTypeEnum.ObjectUser:
case BinaryTypeEnum.ObjectArray:
case BinaryTypeEnum.StringArray:
case BinaryTypeEnum.PrimitiveArray:
byte num = this.dataReader.ReadByte();
binaryHeaderEnum = (BinaryHeaderEnum)num;
switch (binaryHeaderEnum)
{
case BinaryHeaderEnum.Object:
this.ReadObject();
break;
case BinaryHeaderEnum.ObjectWithMap:
case BinaryHeaderEnum.ObjectWithMapAssemId:
this.ReadObjectWithMap(binaryHeaderEnum);
break;
case BinaryHeaderEnum.ObjectWithMapTyped:
case BinaryHeaderEnum.ObjectWithMapTypedAssemId:
this.ReadObjectWithMapTyped(binaryHeaderEnum);
break;
case BinaryHeaderEnum.ObjectString:
case BinaryHeaderEnum.CrossAppDomainString:
this.ReadObjectString(binaryHeaderEnum);
break;
case BinaryHeaderEnum.Array:
case BinaryHeaderEnum.ArraySinglePrimitive:
case BinaryHeaderEnum.ArraySingleObject:
case BinaryHeaderEnum.ArraySingleString:
this.ReadArray(binaryHeaderEnum);
break;
case BinaryHeaderEnum.MemberPrimitiveTyped:
this.ReadMemberPrimitiveTyped();
break;
case BinaryHeaderEnum.MemberReference:
this.ReadMemberReference();
break;
case BinaryHeaderEnum.ObjectNull:
case BinaryHeaderEnum.ObjectNullMultiple256:
case BinaryHeaderEnum.ObjectNullMultiple:
this.ReadObjectNull(binaryHeaderEnum);
break;
case BinaryHeaderEnum.MessageEnd:
flag1 = false;
this.ReadMessageEnd();
this.ReadEnd();
break;
case BinaryHeaderEnum.Assembly:
case BinaryHeaderEnum.CrossAppDomainAssembly:
this.ReadAssembly(binaryHeaderEnum);
break;
case BinaryHeaderEnum.CrossAppDomainMap:
this.ReadCrossAppDomainMap();
break;
case BinaryHeaderEnum.MethodCall:
case BinaryHeaderEnum.MethodReturn:
this.ReadMethodObject(binaryHeaderEnum);
break;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_BinaryHeader", (object)num));
}
default:
throw new SerializationException(Environment.GetResourceString("Serialization_TypeExpected"));
}
if (binaryHeaderEnum != BinaryHeaderEnum.Assembly)
{
bool flag2 = false;
while (!flag2)
{
ObjectProgress op = (ObjectProgress)this.stack.Peek();
if (op == null)
{
this.expectedType = BinaryTypeEnum.ObjectUrt;
this.expectedTypeInformation = (object)null;
flag2 = true;
}
else
{
ObjectProgress objectProgress = op;
// ISSUE: explicit reference operation
// ISSUE: variable of a reference type
BinaryTypeEnum& outBinaryTypeEnum = @objectProgress.expectedType;
// ISSUE: explicit reference operation
// ISSUE: variable of a reference type
object& outTypeInformation = @op.expectedTypeInformation;
flag2 = objectProgress.GetNext(outBinaryTypeEnum, outTypeInformation);
this.expectedType = op.expectedType;
this.expectedTypeInformation = op.expectedTypeInformation;
if (!flag2)
{
this.prs.Init();
if (op.memberValueEnum == InternalMemberValueE.Nested)
{
this.prs.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
this.prs.PRmemberTypeEnum = op.memberTypeEnum;
this.prs.PRmemberValueEnum = op.memberValueEnum;
this.objectReader.Parse(this.prs);
}
else
{
this.prs.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
this.prs.PRmemberTypeEnum = op.memberTypeEnum;
this.prs.PRmemberValueEnum = op.memberValueEnum;
this.objectReader.Parse(this.prs);
}
this.stack.Pop();
this.PutOp(op);
}
}
}
}
}
}
catch (EndOfStreamException ex)
{
throw new SerializationException(Environment.GetResourceString("Serialization_StreamEnd"));
}
}
