internal void Fixup(ParseRecord record, ParseRecord parent)
{
object pRnewObj = record.PRnewObj;
switch (this.valueFixupEnum)
{
case ValueFixupEnum.Array:
this.arrayObj.SetValue(pRnewObj, this.indexMap);
return;
case ValueFixupEnum.Header:
{
Type type = typeof(Header);
if (valueInfo == null)
{
MemberInfo[] member = type.GetMember("Value");
if (member.Length != 1)
{
throw new SerializationException(Environment.GetResourceString("Serialization_HeaderReflection", new object[] { member.Length }));
}
valueInfo = member[0];
break;
}
break;
}
case ValueFixupEnum.Member:
if (!this.objectInfo.isSi)
{
MemberInfo memberInfo = this.objectInfo.GetMemberInfo(this.memberName);
if (memberInfo != null)
{
this.objectInfo.objectManager.RecordFixup(parent.PRobjectId, memberInfo, record.PRobjectId);
}
return;
}
this.objectInfo.objectManager.RecordDelayedFixup(parent.PRobjectId, this.memberName, record.PRobjectId);
return;
default:
return;
}
FormatterServices.SerializationSetValue(valueInfo, this.header, pRnewObj);
}
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(String.Format(Environment.GetResourceString("Serialization_AssemblyId"), record.name));
}
assemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[record.assemId];
if (assemblyInfo == null)
{
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_AssemblyId"), record.assemId + " " + record.name));
}
SerTrace.Log(this, "ReadObjectWithMapTyped lookup assemIdToAssembly assemId ", record.assemId, " assembly ", assemblyInfo.assemblyString);
}
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.PRparseTypeEnum = InternalParseTypeE.Object;
op.memberValueEnum = InternalMemberValueE.Empty;
}
else
{
// Nested Object
pr.PRparseTypeEnum = InternalParseTypeE.Member;
pr.PRmemberValueEnum = InternalMemberValueE.Nested;
op.memberValueEnum = InternalMemberValueE.Nested;
switch (objectOp.objectTypeEnum)
{
case InternalObjectTypeE.Object:
pr.PRname = objectOp.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(String.Format(Environment.GetResourceString("Serialization_ObjectTypeEnum"), ((Enum)objectOp.objectTypeEnum).ToString()));
}
}
pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData);
pr.PRobjectId = objectReader.GetId((long)record.objectId);
if (pr.PRobjectId == topId)
{
pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
}
pr.PRkeyDt = record.name;
pr.PRdtType = objectMap.objectType;
pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
objectReader.Parse(pr);
}
private void ParseObject(ParseRecord pr)
{
if (!this.bFullDeserialization)
{
this.InitFullDeserialization();
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.topId = pr.PRobjectId;
}
if (pr.PRparseTypeEnum == InternalParseTypeE.Object)
{
this.stack.Push(pr);
}
if (pr.PRobjectTypeEnum == InternalObjectTypeE.Array)
{
this.ParseArray(pr);
}
else if (pr.PRdtType == null)
{
pr.PRnewObj = new TypeLoadExceptionHolder(pr.PRkeyDt);
}
else if (object.ReferenceEquals(pr.PRdtType, Converter.typeofString))
{
if (pr.PRvalue != null)
{
pr.PRnewObj = pr.PRvalue;
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = pr.PRnewObj;
}
else
{
this.stack.Pop();
this.RegisterObject(pr.PRnewObj, pr, (ParseRecord) this.stack.Peek());
}
}
}
else
{
this.CheckSerializable(pr.PRdtType);
if (this.IsRemoting && (this.formatterEnums.FEsecurityLevel != TypeFilterLevel.Full))
{
pr.PRnewObj = FormatterServices.GetSafeUninitializedObject(pr.PRdtType);
}
else
{
pr.PRnewObj = FormatterServices.GetUninitializedObject(pr.PRdtType);
}
this.m_objectManager.RaiseOnDeserializingEvent(pr.PRnewObj);
if (pr.PRnewObj == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_TopObjectInstantiate", new object[] { pr.PRdtType }));
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = pr.PRnewObj;
}
if (pr.PRobjectInfo == null)
{
pr.PRobjectInfo = ReadObjectInfo.Create(pr.PRdtType, this.m_surrogates, this.m_context, this.m_objectManager, this.serObjectInfoInit, this.m_formatterConverter, this.bSimpleAssembly);
}
this.CheckSecurity(pr);
}
}
private void ParseError(ParseRecord processing, ParseRecord onStack)
{
throw new SerializationException(Environment.GetResourceString("Serialization_ParseError", new object[] { string.Concat(new object[] { onStack.PRname, " ", onStack.PRparseTypeEnum, " ", processing.PRname, " ", processing.PRparseTypeEnum }) }));
}
internal void Parse(ParseRecord pr)
{
switch (pr.PRparseTypeEnum)
{
case InternalParseTypeE.SerializedStreamHeader:
this.ParseSerializedStreamHeader(pr);
return;
case InternalParseTypeE.Object:
this.ParseObject(pr);
return;
case InternalParseTypeE.Member:
this.ParseMember(pr);
return;
case InternalParseTypeE.ObjectEnd:
this.ParseObjectEnd(pr);
return;
case InternalParseTypeE.MemberEnd:
this.ParseMemberEnd(pr);
return;
case InternalParseTypeE.SerializedStreamHeaderEnd:
this.ParseSerializedStreamHeaderEnd(pr);
return;
case InternalParseTypeE.Envelope:
case InternalParseTypeE.EnvelopeEnd:
case InternalParseTypeE.Body:
case InternalParseTypeE.BodyEnd:
return;
}
throw new SerializationException(Environment.GetResourceString("Serialization_XMLElement", new object[] { pr.PRname }));
}
private void ParseString(ParseRecord pr, ParseRecord parentPr)
{
if (!pr.PRisRegistered && (pr.PRobjectId > 0L))
{
this.RegisterObject(pr.PRvalue, pr, parentPr, true);
}
}
// Object member encountered in stream
private void ParseMember(ParseRecord pr)
{
SerTrace.Log( this, "ParseMember Entry ");
ParseRecord objectPr = (ParseRecord)stack.Peek();
String objName = null;
if (objectPr != null)
objName = objectPr.PRname;
SerTrace.Log( this, "ParseMember ",objectPr.PRobjectId," ",pr.PRname);
SerTrace.Log( this, "ParseMember objectPr ",objectPr.Trace());
SerTrace.Log( this, "ParseMember pr ",pr.Trace());
switch (pr.PRmemberTypeEnum)
{
case InternalMemberTypeE.Item:
ParseArrayMember(pr);
return;
case InternalMemberTypeE.Field:
break;
}
//if ((pr.PRdtType == null) && !objectPr.PRobjectInfo.isSi)
if ((pr.PRdtType == null) && objectPr.PRobjectInfo.isTyped)
{
SerTrace.Log( this, "ParseMember pr.PRdtType null and not isSi");
pr.PRdtType = objectPr.PRobjectInfo.GetType(pr.PRname);
if (pr.PRdtType == null)
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_TypeResolved"), objectPr.PRnewObj+" "+pr.PRname));
pr.PRdtTypeCode = Converter.ToCode(pr.PRdtType);
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Null)
{
// Value is Null
SerTrace.Log( this, "ParseMember null member: ",pr.PRname);
SerTrace.Log( this, "AddValue 1");
objectPr.PRobjectInfo.AddValue(pr.PRname, null, ref objectPr.PRsi, ref objectPr.PRmemberData);
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
SerTrace.Log( this, "ParseMember Nested Type member: ",pr.PRname," objectPr.PRnewObj ",objectPr.PRnewObj);
ParseObject(pr);
stack.Push(pr);
SerTrace.Log( this, "AddValue 2 ",pr.PRnewObj," is value type ",pr.PRnewObj.GetType().IsValueType);
if ((pr.PRobjectInfo != null) && (pr.PRobjectInfo.objectType.IsValueType))
{
SerTrace.Log( "ParseMember ValueType ObjectPr ",objectPr.PRnewObj," memberName ",pr.PRname," nested object ",pr.PRnewObj);
pr.PRisValueTypeFixup = true; //Valuefixup
ValueFixupStack.Push(new ValueFixup(objectPr.PRnewObj, pr.PRname, objectPr.PRobjectInfo));//valuefixup
}
else
{
SerTrace.Log( this, "AddValue 2A ");
objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRnewObj, ref objectPr.PRsi, ref objectPr.PRmemberData);
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Reference)
{
SerTrace.Log( this, "ParseMember Reference Type member: ",pr.PRname);
// See if object has already been instantiated
Object refObj = m_objectManager.GetObject(pr.PRidRef);
if (refObj == null)
{
SerTrace.Log( this, "ParseMember RecordFixup: ",pr.PRname);
SerTrace.Log( this, "AddValue 3");
objectPr.PRobjectInfo.AddValue(pr.PRname, null, ref objectPr.PRsi, ref objectPr.PRmemberData);
objectPr.PRobjectInfo.RecordFixup(objectPr.PRobjectId, pr.PRname, pr.PRidRef); // Object not instantiated
}
else
{
SerTrace.Log( this, "ParseMember Referenced Object Known ",pr.PRname," ",refObj);
SerTrace.Log( this, "AddValue 5");
objectPr.PRobjectInfo.AddValue(pr.PRname, refObj, ref objectPr.PRsi, ref objectPr.PRmemberData);
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue)
{
// Primitive type or String
SerTrace.Log( this, "ParseMember primitive or String member: ",pr.PRname);
if (pr.PRdtType == Converter.typeofString)
{
ParseString(pr, objectPr);
SerTrace.Log( this, "AddValue 6");
objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue, ref objectPr.PRsi, ref objectPr.PRmemberData);
}
else if (pr.PRdtTypeCode == InternalPrimitiveTypeE.Invalid)
{
// The member field was an object put the value is Inline either bin.Base64 or invalid
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
{
SerTrace.Log( this, "AddValue 7");
objectPr.PRobjectInfo.AddValue(pr.PRname, Convert.FromBase64String(pr.PRvalue), ref objectPr.PRsi, ref objectPr.PRmemberData);
}
else if (pr.PRdtType == Converter.typeofObject)
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_TypeMissing"), pr.PRname));
else
{
SerTrace.Log( this, "Object Class with no memberInfo data Member "+pr.PRname+" type "+pr.PRdtType);
ParseString(pr, objectPr); // Register the object if it has an objectId
// Object Class with no memberInfo data
// only special case where AddValue is needed?
if (pr.PRdtType == Converter.typeofSystemVoid)
{
SerTrace.Log( this, "AddValue 9");
objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRdtType, ref objectPr.PRsi, ref objectPr.PRmemberData);
}
else if (objectPr.PRobjectInfo.isSi)
{
// ISerializable are added as strings, the conversion to type is done by the
// ISerializable object
SerTrace.Log( this, "AddValue 10");
objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue, ref objectPr.PRsi, ref objectPr.PRmemberData);
}
}
}
else
{
Object var = null;
if (pr.PRvarValue != null)
var = pr.PRvarValue;
else
var = Converter.FromString(pr.PRvalue, pr.PRdtTypeCode);
// Not a string, convert the value
SerTrace.Log( this, "ParseMember Converting primitive and storing");
stack.Dump();
SerTrace.Log( this, "ParseMember pr "+pr.Trace());
SerTrace.Log( this, "ParseMember objectPr ",objectPr.Trace());
SerTrace.Log( this, "AddValue 11");
objectPr.PRobjectInfo.AddValue(pr.PRname, var, ref objectPr.PRsi, ref objectPr.PRmemberData);
}
}
else
ParseError(pr, objectPr);
}
// Array object encountered in stream
private void ParseArray(ParseRecord pr)
{
SerTrace.Log( this, "ParseArray Entry");
long genId = pr.PRobjectId;
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
{
SerTrace.Log( this, "ParseArray bin.base64 ",pr.PRvalue.Length," ",pr.PRvalue);
// ByteArray
if (pr.PRvalue.Length > 0)
pr.PRnewObj = Convert.FromBase64String(pr.PRvalue);
else
pr.PRnewObj = new Byte[0];
if (stack.Peek() == pr)
{
SerTrace.Log( this, "ParseArray, bin.base64 has been stacked");
stack.Pop();
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
topObject = pr.PRnewObj;
ParseRecord parentPr = (ParseRecord)stack.Peek();
// Base64 can be registered at this point because it is populated
SerTrace.Log( this, "ParseArray RegisterObject ",pr.PRobjectId," ",pr.PRnewObj.GetType());
RegisterObject(pr.PRnewObj, pr, parentPr);
}
else if ((pr.PRnewObj != null) && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
{
// Primtive typed Array has already been read
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
topObject = pr.PRnewObj;
ParseRecord parentPr = (ParseRecord)stack.Peek();
// Primitive typed array can be registered at this point because it is populated
SerTrace.Log( this, "ParseArray RegisterObject ",pr.PRobjectId," ",pr.PRnewObj.GetType());
RegisterObject(pr.PRnewObj, pr, parentPr);
}
else if ((pr.PRarrayTypeEnum == InternalArrayTypeE.Jagged) || (pr.PRarrayTypeEnum == InternalArrayTypeE.Single))
{
// Multidimensional jagged array or single array
SerTrace.Log( this, "ParseArray Before Jagged,Simple create ",pr.PRarrayElementType," ",pr.PRlengthA[0]);
bool bCouldBeValueType = true;
if ((pr.PRlowerBoundA == null) || (pr.PRlowerBoundA[0] == 0))
{
if (pr.PRarrayElementType == Converter.typeofString)
{
pr.PRobjectA = new String[pr.PRlengthA[0]];
pr.PRnewObj = pr.PRobjectA;
bCouldBeValueType = false;
}
else if (pr.PRarrayElementType == Converter.typeofObject)
{
pr.PRobjectA = new Object[pr.PRlengthA[0]];
pr.PRnewObj = pr.PRobjectA;
bCouldBeValueType = false;
}
else
pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA[0]);
pr.PRisLowerBound = false;
}
else
{
pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
pr.PRisLowerBound = true;
}
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Single)
{
if (!pr.PRisLowerBound && (Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode)))
{
pr.PRprimitiveArray = new PrimitiveArray(pr.PRarrayElementTypeCode, (Array)pr.PRnewObj);
}
else if (bCouldBeValueType)
{
if (!pr.PRarrayElementType.IsValueType)
pr.PRobjectA = (Object[])pr.PRnewObj;
}
}
SerTrace.Log( this, "ParseArray Jagged,Simple Array ",pr.PRnewObj.GetType());
// For binary, headers comes in as an array of header objects
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Headers)
{
SerTrace.Log( this, "ParseArray header array");
headers = (Header[])pr.PRnewObj;
}
pr.PRindexMap = new int[1];
}
else if (pr.PRarrayTypeEnum == InternalArrayTypeE.Rectangular)
{
// Rectangle array
pr.PRisLowerBound = false;
if (pr.PRlowerBoundA != null)
{
for (int i=0; i<pr.PRrank; i++)
{
if (pr.PRlowerBoundA[i] != 0)
pr.PRisLowerBound = true;
}
}
if (!pr.PRisLowerBound)
pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA);
else
pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
SerTrace.Log( this, "ParseArray Rectangle Array ",pr.PRnewObj.GetType()," lower Bound ",pr.PRisLowerBound);
// Calculate number of items
int sum = 1;
for (int i=0; i<pr.PRrank; i++)
{
sum = sum*pr.PRlengthA[i];
}
pr.PRindexMap = new int[pr.PRrank];
pr.PRrectangularMap = new int[pr.PRrank];
pr.PRlinearlength = sum;
}
else
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_ArrayType"),((Enum)pr.PRarrayTypeEnum)));
CheckSecurity(pr);
SerTrace.Log( this, "ParseArray Exit");
}
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 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 ParseMember(ParseRecord pr)
{
ParseRecord parseRecord = (ParseRecord)this.stack.Peek();
if (parseRecord != null)
{
string str = parseRecord.PRname;
}
switch (pr.PRmemberTypeEnum)
{
case InternalMemberTypeE.Item:
this.ParseArrayMember(pr);
break;
default:
if (pr.PRdtType == null && parseRecord.PRobjectInfo.isTyped)
{
pr.PRdtType = parseRecord.PRobjectInfo.GetType(pr.PRname);
if (pr.PRdtType != null)
{
pr.PRdtTypeCode = Converter.ToCode(pr.PRdtType);
}
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Null)
{
parseRecord.PRobjectInfo.AddValue(pr.PRname, (object)null, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
this.ParseObject(pr);
this.stack.Push((object)pr);
if (pr.PRobjectInfo != null && pr.PRobjectInfo.objectType != null && pr.PRobjectInfo.objectType.IsValueType)
{
pr.PRisValueTypeFixup = true;
this.ValueFixupStack.Push((object)new ValueFixup(parseRecord.PRnewObj, pr.PRname, parseRecord.PRobjectInfo));
break;
}
parseRecord.PRobjectInfo.AddValue(pr.PRname, pr.PRnewObj, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Reference)
{
object @object = this.m_objectManager.GetObject(pr.PRidRef);
if (@object == null)
{
parseRecord.PRobjectInfo.AddValue(pr.PRname, (object)null, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
parseRecord.PRobjectInfo.RecordFixup(parseRecord.PRobjectId, pr.PRname, pr.PRidRef);
break;
}
parseRecord.PRobjectInfo.AddValue(pr.PRname, @object, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue)
{
if (pr.PRdtType == Converter.typeofString)
{
this.ParseString(pr, parseRecord);
parseRecord.PRobjectInfo.AddValue(pr.PRname, (object)pr.PRvalue, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
if (pr.PRdtTypeCode == InternalPrimitiveTypeE.Invalid)
{
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
{
parseRecord.PRobjectInfo.AddValue(pr.PRname, (object)Convert.FromBase64String(pr.PRvalue), ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
if (pr.PRdtType == Converter.typeofObject)
{
throw new SerializationException(Environment.GetResourceString("Serialization_TypeMissing", (object)pr.PRname));
}
this.ParseString(pr, parseRecord);
if (pr.PRdtType == Converter.typeofSystemVoid)
{
parseRecord.PRobjectInfo.AddValue(pr.PRname, (object)pr.PRdtType, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
if (!parseRecord.PRobjectInfo.isSi)
{
break;
}
parseRecord.PRobjectInfo.AddValue(pr.PRname, (object)pr.PRvalue, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
object obj = pr.PRvarValue == null?Converter.FromString(pr.PRvalue, pr.PRdtTypeCode) : pr.PRvarValue;
parseRecord.PRobjectInfo.AddValue(pr.PRname, obj, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
this.ParseError(pr, parseRecord);
break;
}
}
private void ParseArray(ParseRecord pr)
{
long num1 = pr.PRobjectId;
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
{
pr.PRnewObj = pr.PRvalue.Length <= 0 ? (object)new byte[0] : (object)Convert.FromBase64String(pr.PRvalue);
if (this.stack.Peek() == pr)
{
this.stack.Pop();
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = pr.PRnewObj;
}
ParseRecord objectPr = (ParseRecord)this.stack.Peek();
this.RegisterObject(pr.PRnewObj, pr, objectPr);
}
else if (pr.PRnewObj != null && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
{
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = pr.PRnewObj;
}
ParseRecord objectPr = (ParseRecord)this.stack.Peek();
this.RegisterObject(pr.PRnewObj, pr, objectPr);
}
else if (pr.PRarrayTypeEnum == InternalArrayTypeE.Jagged || pr.PRarrayTypeEnum == InternalArrayTypeE.Single)
{
bool flag = true;
if (pr.PRlowerBoundA == null || pr.PRlowerBoundA[0] == 0)
{
if (pr.PRarrayElementType == Converter.typeofString)
{
ParseRecord parseRecord1 = pr;
string[] strArray = new string[parseRecord1.PRlengthA[0]];
parseRecord1.PRobjectA = (object[])strArray;
ParseRecord parseRecord2 = pr;
object[] objArray = parseRecord2.PRobjectA;
parseRecord2.PRnewObj = (object)objArray;
flag = false;
}
else if (pr.PRarrayElementType == Converter.typeofObject)
{
ParseRecord parseRecord1 = pr;
object[] objArray1 = new object[parseRecord1.PRlengthA[0]];
parseRecord1.PRobjectA = objArray1;
ParseRecord parseRecord2 = pr;
object[] objArray2 = parseRecord2.PRobjectA;
parseRecord2.PRnewObj = (object)objArray2;
flag = false;
}
else if (pr.PRarrayElementType != null)
{
pr.PRnewObj = (object)Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA[0]);
}
pr.PRisLowerBound = false;
}
else
{
if (pr.PRarrayElementType != null)
{
pr.PRnewObj = (object)Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
}
pr.PRisLowerBound = true;
}
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Single)
{
if (!pr.PRisLowerBound && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
{
ParseRecord parseRecord = pr;
PrimitiveArray primitiveArray = new PrimitiveArray(parseRecord.PRarrayElementTypeCode, (Array)pr.PRnewObj);
parseRecord.PRprimitiveArray = primitiveArray;
}
else if (flag && pr.PRarrayElementType != null && (!pr.PRarrayElementType.IsValueType && !pr.PRisLowerBound))
{
ParseRecord parseRecord = pr;
object[] objArray = (object[])parseRecord.PRnewObj;
parseRecord.PRobjectA = objArray;
}
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Headers)
{
this.headers = (Header[])pr.PRnewObj;
}
pr.PRindexMap = new int[1];
}
else if (pr.PRarrayTypeEnum == InternalArrayTypeE.Rectangular)
{
pr.PRisLowerBound = false;
if (pr.PRlowerBoundA != null)
{
for (int index = 0; index < pr.PRrank; ++index)
{
if (pr.PRlowerBoundA[index] != 0)
{
pr.PRisLowerBound = true;
}
}
}
if (pr.PRarrayElementType != null)
{
pr.PRnewObj = pr.PRisLowerBound ? (object)Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA) : (object)Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA);
}
int num2 = 1;
for (int index = 0; index < pr.PRrank; ++index)
{
num2 *= pr.PRlengthA[index];
}
ParseRecord parseRecord1 = pr;
int[] numArray1 = new int[parseRecord1.PRrank];
parseRecord1.PRindexMap = numArray1;
ParseRecord parseRecord2 = pr;
int[] numArray2 = new int[parseRecord2.PRrank];
parseRecord2.PRrectangularMap = numArray2;
pr.PRlinearlength = num2;
}
else
{
throw new SerializationException(Environment.GetResourceString("Serialization_ArrayType", (object)pr.PRarrayTypeEnum));
}
this.CheckSecurity(pr);
}
private void ParseError(ParseRecord processing, ParseRecord onStack)
{
throw new SerializationException(Environment.GetResourceString("Serialization_ParseError", (object)(onStack.PRname + " " + (object)onStack.PRparseTypeEnum + " " + processing.PRname + " " + (object)processing.PRparseTypeEnum)));
}
private void ReadArray(BinaryHeaderEnum binaryHeaderEnum)
{
BinaryAssemblyInfo assemblyInfo = null;
SerTrace.Log(this, "ReadArray ");
BinaryArray record = new BinaryArray(binaryHeaderEnum);
record.Read(this);
record.Dump();
SerTrace.Log(this, "Read 1 ", ((Enum)binaryHeaderEnum).ToString());
if (record.binaryTypeEnum == BinaryTypeEnum.ObjectUser)
{
if (record.assemId < 1)
{
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_AssemblyId"), record.typeInformation));
}
assemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[record.assemId];
SerTrace.Log(this, "ReadArray lookup assemIdToAssembly assemId ", record.assemId, " assembly ", assemblyInfo.assemblyString);
}
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.PRparseTypeEnum = InternalParseTypeE.Object;
op.memberValueEnum = InternalMemberValueE.Empty;
}
else
{
// Nested Object
pr.PRparseTypeEnum = InternalParseTypeE.Member;
pr.PRmemberValueEnum = InternalMemberValueE.Nested;
op.memberValueEnum = InternalMemberValueE.Nested;
switch (objectOp.objectTypeEnum)
{
case InternalObjectTypeE.Object:
pr.PRname = objectOp.name;
pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
op.memberTypeEnum = InternalMemberTypeE.Field;
pr.PRkeyDt = objectOp.name;
pr.PRdtType = objectOp.dtType;
break;
case InternalObjectTypeE.Array:
pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
op.memberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_ObjectTypeEnum"), ((Enum)objectOp.objectTypeEnum).ToString()));
}
}
pr.PRobjectId = objectReader.GetId((long)record.objectId);
if (pr.PRobjectId == topId)
{
pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
}
else if ((headerId > 0) && (pr.PRobjectId == headerId))
{
pr.PRobjectPositionEnum = InternalObjectPositionE.Headers; // Headers are an array of header objects
}
else
{
pr.PRobjectPositionEnum = InternalObjectPositionE.Child;
}
pr.PRobjectTypeEnum = InternalObjectTypeE.Array;
BinaryConverter.TypeFromInfo(record.binaryTypeEnum, record.typeInformation, objectReader, assemblyInfo,
out pr.PRarrayElementTypeCode, out pr.PRarrayElementTypeString,
out pr.PRarrayElementType, out pr.PRisArrayVariant);
pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
pr.PRrank = record.rank;
pr.PRlengthA = record.lengthA;
pr.PRlowerBoundA = record.lowerBoundA;
bool isPrimitiveArray = false;
switch (record.binaryArrayTypeEnum)
{
case BinaryArrayTypeEnum.Single:
case BinaryArrayTypeEnum.SingleOffset:
op.numItems = record.lengthA[0];
pr.PRarrayTypeEnum = InternalArrayTypeE.Single;
if (Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode) &&
(record.lowerBoundA[0] == 0))
{
isPrimitiveArray = true;
ReadArrayAsBytes(pr);
}
break;
case BinaryArrayTypeEnum.Jagged:
case BinaryArrayTypeEnum.JaggedOffset:
op.numItems = record.lengthA[0];
pr.PRarrayTypeEnum = 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.PRarrayTypeEnum = InternalArrayTypeE.Rectangular;
break;
default:
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_ArrayType"), ((Enum)record.binaryArrayTypeEnum).ToString()));
}
if (!isPrimitiveArray)
{
stack.Push(op);
}
else
{
PutOp(op);
}
SerTrace.Log(this, "ReadArray ", ((Enum)record.binaryArrayTypeEnum).ToString(), " length ", op.numItems);
objectReader.Parse(pr);
if (isPrimitiveArray)
{
pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
objectReader.Parse(pr);
}
}
// Parse the SerializedStreamHeader end element. This is the last element in the stream if present
private void ParseSerializedStreamHeaderEnd(ParseRecord pr)
{
SerTrace.Log( this, "SerializedHeaderEnd ",pr);
stack.Pop();
}
// New object encountered in stream
private void ParseObject(ParseRecord pr)
{
SerTrace.Log( this, "ParseObject Entry ");
if (!bFullDeserialization)
InitFullDeserialization();
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
topId = pr.PRobjectId;
if (pr.PRparseTypeEnum == InternalParseTypeE.Object)
{
stack.Push(pr); // Nested objects member names are already on stack
}
if (pr.PRobjectTypeEnum == InternalObjectTypeE.Array)
{
ParseArray(pr);
SerTrace.Log( this, "ParseObject Exit, ParseArray ");
return;
}
if (pr.PRdtType == null)
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_TopObjectInstantiate"),pr.PRname));
if (pr.PRdtType == Converter.typeofString)
{
// String as a top level object
if (pr.PRvalue != null)
{
pr.PRnewObj = pr.PRvalue;
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
SerTrace.Log( this, "ParseObject String as top level, Top Object Resolved");
isTopObjectResolved = true;
topObject = pr.PRnewObj;
//stack.Pop();
return;
}
else
{
SerTrace.Log( this, "ParseObject String as an object");
stack.Pop();
RegisterObject(pr.PRnewObj, pr, (ParseRecord)stack.Peek());
return;
}
}
else
{
// xml Doesn't have the value until later
return;
}
}
else {
pr.PRnewObj = FormatterServices.GetUninitializedObject(pr.PRdtType);
}
if (pr.PRnewObj == null)
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_TopObjectInstantiate"),pr.PRdtType));
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
isTopObjectResolved = true;
topObject = pr.PRnewObj;
}
if (pr.PRobjectInfo == null)
pr.PRobjectInfo = ReadObjectInfo.Create(pr.PRdtType, m_surrogates, m_context, m_objectManager, serObjectInfoInit, m_formatterConverter, bSimpleAssembly);
CheckSecurity(pr);
SerTrace.Log( this, "ParseObject Exit ");
}
private void ParseObject(ParseRecord pr)
{
if (!this.bFullDeserialization)
{
this.InitFullDeserialization();
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.topId = pr.PRobjectId;
}
if (pr.PRparseTypeEnum == InternalParseTypeE.Object)
{
this.stack.Push(pr);
}
if (pr.PRobjectTypeEnum == InternalObjectTypeE.Array)
{
this.ParseArray(pr);
return;
}
if (pr.PRdtType == null)
{
pr.PRnewObj = new TypeLoadExceptionHolder(pr.PRkeyDt);
return;
}
if (pr.PRdtType == Converter.typeofString)
{
if (pr.PRvalue == null)
{
return;
}
pr.PRnewObj = pr.PRvalue;
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = pr.PRnewObj;
return;
}
this.stack.Pop();
this.RegisterObject(pr.PRnewObj, pr, (ParseRecord)this.stack.Peek());
return;
}
else
{
this.CheckSerializable(pr.PRdtType);
if (this.IsRemoting && this.formatterEnums.FEsecurityLevel != TypeFilterLevel.Full)
{
pr.PRnewObj = FormatterServices.GetSafeUninitializedObject(pr.PRdtType);
}
else
{
pr.PRnewObj = FormatterServices.GetUninitializedObject(pr.PRdtType);
}
this.m_objectManager.RaiseOnDeserializingEvent(pr.PRnewObj);
if (pr.PRnewObj == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_TopObjectInstantiate", new object[]
{
pr.PRdtType
}));
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = pr.PRnewObj;
}
if (pr.PRobjectInfo == null)
{
pr.PRobjectInfo = ReadObjectInfo.Create(pr.PRdtType, this.m_surrogates, this.m_context, this.m_objectManager, this.serObjectInfoInit, this.m_formatterConverter, this.bSimpleAssembly);
}
this.CheckSecurity(pr);
return;
}
}
// Array object item encountered in stream
private void ParseArrayMember(ParseRecord pr)
{
SerTrace.Log( this, "ParseArrayMember Entry");
ParseRecord objectPr = (ParseRecord)stack.Peek();
// Set up for inserting value into correct array position
if (objectPr.PRarrayTypeEnum == InternalArrayTypeE.Rectangular)
{
if (objectPr.PRmemberIndex > 0)
NextRectangleMap(objectPr); // Rectangle array, calculate position in array
if (objectPr.PRisLowerBound)
{
for (int i=0; i<objectPr.PRrank; i++)
{
if (objectPr.PRpositionA == null)
objectPr.PRindexMap[i] = objectPr.PRrectangularMap[i] + objectPr.PRlowerBoundA[i];
else
objectPr.PRindexMap[i] = objectPr.PRpositionA[i];
}
}
}
else
{
if (!objectPr.PRisLowerBound)
{
if (objectPr.PRpositionA == null)
objectPr.PRindexMap[0] = objectPr.PRmemberIndex; // Zero based array
else
objectPr.PRindexMap[0] = objectPr.PRpositionA[0]; // item position specified in SOAP stream
}
else
objectPr.PRindexMap[0] = objectPr.PRlowerBoundA[0]+objectPr.PRmemberIndex; // Lower Bound based array
}
IndexTraceMessage("ParseArrayMember isLowerBound "+objectPr.PRisLowerBound+" indexMap ", objectPr.PRindexMap);
// Set Array element according to type of element
if (pr.PRmemberValueEnum == InternalMemberValueE.Reference)
{
// Object Reference
// See if object has already been instantiated
Object refObj = m_objectManager.GetObject(pr.PRidRef);
if (refObj == null)
{
// Object not instantiated
// Array fixup manager
IndexTraceMessage("ParseArrayMember Record Fixup "+objectPr.PRnewObj.GetType(), objectPr.PRindexMap);
int[] fixupIndex = new int[objectPr.PRrank];
Array.Copy(objectPr.PRindexMap, 0, fixupIndex, 0, objectPr.PRrank);
SerTrace.Log( this, "ParseArrayMember RecordArrayElementFixup objectId ",objectPr.PRobjectId," idRef ",pr.PRidRef);
m_objectManager.RecordArrayElementFixup(objectPr.PRobjectId, fixupIndex, pr.PRidRef);
}
else
{
IndexTraceMessage("ParseArrayMember SetValue ObjectReference "+objectPr.PRnewObj.GetType()+" "+refObj, objectPr.PRindexMap);
if (objectPr.PRobjectA != null)
objectPr.PRobjectA[objectPr.PRindexMap[0]] = refObj;
else
((Array)objectPr.PRnewObj).SetValue(refObj, objectPr.PRindexMap); // Object has been instantiated
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
//Set up dtType for ParseObject
SerTrace.Log( this, "ParseArrayMember Nested ");
if (pr.PRdtType == null)
{
pr.PRdtType = objectPr.PRarrayElementType;
}
ParseObject(pr);
stack.Push(pr);
if ((objectPr.PRarrayElementType.IsValueType) && (pr.PRarrayElementTypeCode == InternalPrimitiveTypeE.Invalid))
{
SerTrace.Log( "ParseArrayMember ValueType ObjectPr ",objectPr.PRnewObj," index ",objectPr.PRmemberIndex);
pr.PRisValueTypeFixup = true; //Valuefixup
ValueFixupStack.Push(new ValueFixup((Array)objectPr.PRnewObj, objectPr.PRindexMap)); //valuefixup
pr.PRisRegistered = true;
// No need to register a value object, because there cant be 2 references to same instance of value type
// (we know its not boxed here..array element type IsValueType, not Object)
//RegisterObject(pr.PRnewObj, pr, objectPr);
}
else
{
SerTrace.Log( "ParseArrayMember SetValue Nested, memberIndex ",objectPr.PRmemberIndex);
IndexTraceMessage("ParseArrayMember SetValue Nested ContainerObject "+objectPr.PRnewObj.GetType()+" "+objectPr.PRnewObj+" item Object "+pr.PRnewObj+" index ", objectPr.PRindexMap);
stack.Dump();
SerTrace.Log( "ParseArrayMember SetValue Nested ContainerObject objectPr ",objectPr.Trace());
SerTrace.Log( "ParseArrayMember SetValue Nested ContainerObject pr ",pr.Trace());
if (objectPr.PRobjectA != null)
objectPr.PRobjectA[objectPr.PRindexMap[0]] = pr.PRnewObj;
else
((Array)objectPr.PRnewObj).SetValue(pr.PRnewObj, objectPr.PRindexMap);
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue)
{
if ((objectPr.PRarrayElementType == Converter.typeofString) || (pr.PRdtType == Converter.typeofString))
{
// String in either a string array, or a string element of an object array
ParseString(pr, objectPr);
IndexTraceMessage("ParseArrayMember SetValue String "+objectPr.PRnewObj.GetType()+" "+pr.PRvalue, objectPr.PRindexMap);
if (objectPr.PRobjectA != null)
objectPr.PRobjectA[objectPr.PRindexMap[0]] = (Object)pr.PRvalue;
else
((Array)objectPr.PRnewObj).SetValue((Object)pr.PRvalue, objectPr.PRindexMap);
}
else if (objectPr.PRisArrayVariant)
{
// Array of type object
if (pr.PRkeyDt == null)
throw new SerializationException(Environment.GetResourceString("Serialization_ArrayTypeObject"));
Object var = null;
if (pr.PRdtType == Converter.typeofString)
{
ParseString(pr, objectPr);
var = pr.PRvalue;
}
else if (pr.PRdtTypeCode == InternalPrimitiveTypeE.Invalid)
{
// Not nested and invalid, so it is an empty object
var = FormatterServices.GetUninitializedObject(pr.PRdtType);
}
else
{
if (pr.PRvarValue != null)
var = pr.PRvarValue;
else
var = Converter.FromString(pr.PRvalue, pr.PRdtTypeCode);
}
IndexTraceMessage("ParseArrayMember SetValue variant or Object "+objectPr.PRnewObj.GetType()+" var "+var+" indexMap ", objectPr.PRindexMap);
if (objectPr.PRobjectA != null)
objectPr.PRobjectA[objectPr.PRindexMap[0]] = var;
else
((Array)objectPr.PRnewObj).SetValue(var, objectPr.PRindexMap); // Primitive type
}
else
{
// Primitive type
if (objectPr.PRprimitiveArray != null)
{
// Fast path for Soap primitive arrays. Binary was handled in the BinaryParser
objectPr.PRprimitiveArray.SetValue(pr.PRvalue, objectPr.PRindexMap[0]);
}
else
{
Object var = null;
if (pr.PRvarValue != null)
var = pr.PRvarValue;
else
var = Converter.FromString(pr.PRvalue, objectPr.PRarrayElementTypeCode);
SerTrace.Log( this, "ParseArrayMember SetValue Primitive pr.PRvalue "+var," elementTypeCode ",((Enum)objectPr.PRdtTypeCode));
IndexTraceMessage("ParseArrayMember SetValue Primitive "+objectPr.PRnewObj.GetType()+" var: "+var+" varType "+var.GetType(), objectPr.PRindexMap);
if (objectPr.PRobjectA != null)
{
SerTrace.Log( this, "ParseArrayMember SetValue Primitive predefined array "+objectPr.PRobjectA.GetType());
objectPr.PRobjectA[objectPr.PRindexMap[0]] = var;
}
else
((Array)objectPr.PRnewObj).SetValue(var, objectPr.PRindexMap); // Primitive type
SerTrace.Log( this, "ParseArrayMember SetValue Primitive after");
}
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Null)
{
SerTrace.Log( "ParseArrayMember Null item ",pr.PRmemberIndex," nullCount ",pr.PRnullCount);
objectPr.PRmemberIndex += pr.PRnullCount-1; //also incremented again below
}
else
ParseError(pr, objectPr);
SerTrace.Log( "ParseArrayMember increment memberIndex ",objectPr.PRmemberIndex," ",objectPr.Trace());
objectPr.PRmemberIndex++;
SerTrace.Log( "ParseArrayMember Exit");
}
private void ParseArray(ParseRecord pr)
{
long probjectId = pr.PRobjectId;
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
{
if (pr.PRvalue.Length > 0)
{
pr.PRnewObj = Convert.FromBase64String(pr.PRvalue);
}
else
{
pr.PRnewObj = new byte[0];
}
if (this.stack.Peek() == pr)
{
this.stack.Pop();
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = pr.PRnewObj;
}
ParseRecord objectPr = (ParseRecord)this.stack.Peek();
this.RegisterObject(pr.PRnewObj, pr, objectPr);
}
else if (pr.PRnewObj != null && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
{
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = pr.PRnewObj;
}
ParseRecord objectPr2 = (ParseRecord)this.stack.Peek();
this.RegisterObject(pr.PRnewObj, pr, objectPr2);
}
else if (pr.PRarrayTypeEnum == InternalArrayTypeE.Jagged || pr.PRarrayTypeEnum == InternalArrayTypeE.Single)
{
bool flag = true;
if (pr.PRlowerBoundA == null || pr.PRlowerBoundA[0] == 0)
{
if (pr.PRarrayElementType == Converter.typeofString)
{
pr.PRobjectA = new string[pr.PRlengthA[0]];
pr.PRnewObj = pr.PRobjectA;
flag = false;
}
else if (pr.PRarrayElementType == Converter.typeofObject)
{
pr.PRobjectA = new object[pr.PRlengthA[0]];
pr.PRnewObj = pr.PRobjectA;
flag = false;
}
else if (pr.PRarrayElementType != null)
{
pr.PRnewObj = Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA[0]);
}
pr.PRisLowerBound = false;
}
else
{
if (pr.PRarrayElementType != null)
{
pr.PRnewObj = Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
}
pr.PRisLowerBound = true;
}
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Single)
{
if (!pr.PRisLowerBound && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
{
pr.PRprimitiveArray = new PrimitiveArray(pr.PRarrayElementTypeCode, (Array)pr.PRnewObj);
}
else if (flag && pr.PRarrayElementType != null && !pr.PRarrayElementType.IsValueType && !pr.PRisLowerBound)
{
pr.PRobjectA = (object[])pr.PRnewObj;
}
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Headers)
{
this.headers = (Header[])pr.PRnewObj;
}
pr.PRindexMap = new int[1];
}
else
{
if (pr.PRarrayTypeEnum != InternalArrayTypeE.Rectangular)
{
throw new SerializationException(Environment.GetResourceString("Serialization_ArrayType", new object[]
{
pr.PRarrayTypeEnum
}));
}
pr.PRisLowerBound = false;
if (pr.PRlowerBoundA != null)
{
for (int i = 0; i < pr.PRrank; i++)
{
if (pr.PRlowerBoundA[i] != 0)
{
pr.PRisLowerBound = true;
}
}
}
if (pr.PRarrayElementType != null)
{
if (!pr.PRisLowerBound)
{
pr.PRnewObj = Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA);
}
else
{
pr.PRnewObj = Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
}
}
int num = 1;
for (int j = 0; j < pr.PRrank; j++)
{
num *= pr.PRlengthA[j];
}
pr.PRindexMap = new int[pr.PRrank];
pr.PRrectangularMap = new int[pr.PRrank];
pr.PRlinearlength = num;
}
this.CheckSecurity(pr);
}
private void ParseSerializedStreamHeader(ParseRecord pr)
{
this.stack.Push(pr);
}
private void ParseArrayMember(ParseRecord pr)
{
ParseRecord parseRecord = (ParseRecord)this.stack.Peek();
if (parseRecord.PRarrayTypeEnum == InternalArrayTypeE.Rectangular)
{
if (parseRecord.PRmemberIndex > 0)
{
this.NextRectangleMap(parseRecord);
}
if (parseRecord.PRisLowerBound)
{
for (int i = 0; i < parseRecord.PRrank; i++)
{
parseRecord.PRindexMap[i] = parseRecord.PRrectangularMap[i] + parseRecord.PRlowerBoundA[i];
}
}
}
else if (!parseRecord.PRisLowerBound)
{
parseRecord.PRindexMap[0] = parseRecord.PRmemberIndex;
}
else
{
parseRecord.PRindexMap[0] = parseRecord.PRlowerBoundA[0] + parseRecord.PRmemberIndex;
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Reference)
{
object @object = this.m_objectManager.GetObject(pr.PRidRef);
if (@object == null)
{
int[] array = new int[parseRecord.PRrank];
Array.Copy(parseRecord.PRindexMap, 0, array, 0, parseRecord.PRrank);
this.m_objectManager.RecordArrayElementFixup(parseRecord.PRobjectId, array, pr.PRidRef);
}
else if (parseRecord.PRobjectA != null)
{
parseRecord.PRobjectA[parseRecord.PRindexMap[0]] = @object;
}
else
{
((Array)parseRecord.PRnewObj).SetValue(@object, parseRecord.PRindexMap);
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
if (pr.PRdtType == null)
{
pr.PRdtType = parseRecord.PRarrayElementType;
}
this.ParseObject(pr);
this.stack.Push(pr);
if (parseRecord.PRarrayElementType != null)
{
if (parseRecord.PRarrayElementType.IsValueType && pr.PRarrayElementTypeCode == InternalPrimitiveTypeE.Invalid)
{
pr.PRisValueTypeFixup = true;
this.ValueFixupStack.Push(new ValueFixup((Array)parseRecord.PRnewObj, parseRecord.PRindexMap));
}
else if (parseRecord.PRobjectA != null)
{
parseRecord.PRobjectA[parseRecord.PRindexMap[0]] = pr.PRnewObj;
}
else
{
((Array)parseRecord.PRnewObj).SetValue(pr.PRnewObj, parseRecord.PRindexMap);
}
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue)
{
if (parseRecord.PRarrayElementType == Converter.typeofString || pr.PRdtType == Converter.typeofString)
{
this.ParseString(pr, parseRecord);
if (parseRecord.PRobjectA != null)
{
parseRecord.PRobjectA[parseRecord.PRindexMap[0]] = pr.PRvalue;
}
else
{
((Array)parseRecord.PRnewObj).SetValue(pr.PRvalue, parseRecord.PRindexMap);
}
}
else if (parseRecord.PRisArrayVariant)
{
if (pr.PRkeyDt == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_ArrayTypeObject"));
}
object obj;
if (pr.PRdtType == Converter.typeofString)
{
this.ParseString(pr, parseRecord);
obj = pr.PRvalue;
}
else if (pr.PRdtTypeCode == InternalPrimitiveTypeE.Invalid)
{
this.CheckSerializable(pr.PRdtType);
if (this.IsRemoting && this.formatterEnums.FEsecurityLevel != TypeFilterLevel.Full)
{
obj = FormatterServices.GetSafeUninitializedObject(pr.PRdtType);
}
else
{
obj = FormatterServices.GetUninitializedObject(pr.PRdtType);
}
}
else if (pr.PRvarValue != null)
{
obj = pr.PRvarValue;
}
else
{
obj = Converter.FromString(pr.PRvalue, pr.PRdtTypeCode);
}
if (parseRecord.PRobjectA != null)
{
parseRecord.PRobjectA[parseRecord.PRindexMap[0]] = obj;
}
else
{
((Array)parseRecord.PRnewObj).SetValue(obj, parseRecord.PRindexMap);
}
}
else if (parseRecord.PRprimitiveArray != null)
{
parseRecord.PRprimitiveArray.SetValue(pr.PRvalue, parseRecord.PRindexMap[0]);
}
else
{
object obj2;
if (pr.PRvarValue != null)
{
obj2 = pr.PRvarValue;
}
else
{
obj2 = Converter.FromString(pr.PRvalue, parseRecord.PRarrayElementTypeCode);
}
if (parseRecord.PRobjectA != null)
{
parseRecord.PRobjectA[parseRecord.PRindexMap[0]] = obj2;
}
else
{
((Array)parseRecord.PRnewObj).SetValue(obj2, parseRecord.PRindexMap);
}
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Null)
{
parseRecord.PRmemberIndex += pr.PRnullCount - 1;
}
else
{
this.ParseError(pr, parseRecord);
}
parseRecord.PRmemberIndex++;
}
private void RegisterObject(object obj, ParseRecord pr, ParseRecord objectPr, bool bIsString)
{
if (!pr.PRisRegistered)
{
pr.PRisRegistered = true;
SerializationInfo pRsi = null;
long idOfContainingObj = 0L;
MemberInfo member = null;
int[] arrayIndex = null;
if (objectPr != null)
{
arrayIndex = objectPr.PRindexMap;
idOfContainingObj = objectPr.PRobjectId;
if ((objectPr.PRobjectInfo != null) && !objectPr.PRobjectInfo.isSi)
{
member = objectPr.PRobjectInfo.GetMemberInfo(pr.PRname);
}
}
pRsi = pr.PRsi;
if (bIsString)
{
this.m_objectManager.RegisterString((string) obj, pr.PRobjectId, pRsi, idOfContainingObj, member);
}
else
{
this.m_objectManager.RegisterObject(obj, pr.PRobjectId, pRsi, idOfContainingObj, member, arrayIndex);
}
}
}
private void ParseMember(ParseRecord pr)
{
ParseRecord parseRecord = (ParseRecord)this.stack.Peek();
if (parseRecord != null)
{
string prname = parseRecord.PRname;
}
InternalMemberTypeE prmemberTypeEnum = pr.PRmemberTypeEnum;
if (prmemberTypeEnum != InternalMemberTypeE.Field && prmemberTypeEnum == InternalMemberTypeE.Item)
{
this.ParseArrayMember(pr);
return;
}
if (pr.PRdtType == null && parseRecord.PRobjectInfo.isTyped)
{
pr.PRdtType = parseRecord.PRobjectInfo.GetType(pr.PRname);
if (pr.PRdtType != null)
{
pr.PRdtTypeCode = Converter.ToCode(pr.PRdtType);
}
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Null)
{
parseRecord.PRobjectInfo.AddValue(pr.PRname, null, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
return;
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
this.ParseObject(pr);
this.stack.Push(pr);
if (pr.PRobjectInfo != null && pr.PRobjectInfo.objectType != null && pr.PRobjectInfo.objectType.IsValueType)
{
pr.PRisValueTypeFixup = true;
this.ValueFixupStack.Push(new ValueFixup(parseRecord.PRnewObj, pr.PRname, parseRecord.PRobjectInfo));
return;
}
parseRecord.PRobjectInfo.AddValue(pr.PRname, pr.PRnewObj, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
return;
}
else
{
if (pr.PRmemberValueEnum != InternalMemberValueE.Reference)
{
if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue)
{
if (pr.PRdtType == Converter.typeofString)
{
this.ParseString(pr, parseRecord);
parseRecord.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
return;
}
if (pr.PRdtTypeCode != InternalPrimitiveTypeE.Invalid)
{
object value;
if (pr.PRvarValue != null)
{
value = pr.PRvarValue;
}
else
{
value = Converter.FromString(pr.PRvalue, pr.PRdtTypeCode);
}
parseRecord.PRobjectInfo.AddValue(pr.PRname, value, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
return;
}
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
{
parseRecord.PRobjectInfo.AddValue(pr.PRname, Convert.FromBase64String(pr.PRvalue), ref parseRecord.PRsi, ref parseRecord.PRmemberData);
return;
}
if (pr.PRdtType == Converter.typeofObject)
{
throw new SerializationException(Environment.GetResourceString("Serialization_TypeMissing", new object[]
{
pr.PRname
}));
}
this.ParseString(pr, parseRecord);
if (pr.PRdtType == Converter.typeofSystemVoid)
{
parseRecord.PRobjectInfo.AddValue(pr.PRname, pr.PRdtType, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
return;
}
if (parseRecord.PRobjectInfo.isSi)
{
parseRecord.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
return;
}
}
else
{
this.ParseError(pr, parseRecord);
}
return;
}
object @object = this.m_objectManager.GetObject(pr.PRidRef);
if (@object == null)
{
parseRecord.PRobjectInfo.AddValue(pr.PRname, null, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
parseRecord.PRobjectInfo.RecordFixup(parseRecord.PRobjectId, pr.PRname, pr.PRidRef);
return;
}
parseRecord.PRobjectInfo.AddValue(pr.PRname, @object, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
return;
}
}
private void ParseArrayMember(ParseRecord pr)
{
ParseRecord record = (ParseRecord) this.stack.Peek();
if (record.PRarrayTypeEnum == InternalArrayTypeE.Rectangular)
{
if (record.PRmemberIndex > 0)
{
this.NextRectangleMap(record);
}
if (record.PRisLowerBound)
{
for (int i = 0; i < record.PRrank; i++)
{
record.PRindexMap[i] = record.PRrectangularMap[i] + record.PRlowerBoundA[i];
}
}
}
else if (!record.PRisLowerBound)
{
record.PRindexMap[0] = record.PRmemberIndex;
}
else
{
record.PRindexMap[0] = record.PRlowerBoundA[0] + record.PRmemberIndex;
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Reference)
{
object obj2 = this.m_objectManager.GetObject(pr.PRidRef);
if (obj2 == null)
{
int[] destinationArray = new int[record.PRrank];
Array.Copy(record.PRindexMap, 0, destinationArray, 0, record.PRrank);
this.m_objectManager.RecordArrayElementFixup(record.PRobjectId, destinationArray, pr.PRidRef);
}
else if (record.PRobjectA != null)
{
record.PRobjectA[record.PRindexMap[0]] = obj2;
}
else
{
((Array) record.PRnewObj).SetValue(obj2, record.PRindexMap);
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
if (pr.PRdtType == null)
{
pr.PRdtType = record.PRarrayElementType;
}
this.ParseObject(pr);
this.stack.Push(pr);
if (record.PRarrayElementType != null)
{
if (record.PRarrayElementType.IsValueType && (pr.PRarrayElementTypeCode == InternalPrimitiveTypeE.Invalid))
{
pr.PRisValueTypeFixup = true;
this.ValueFixupStack.Push(new ValueFixup((Array) record.PRnewObj, record.PRindexMap));
}
else if (record.PRobjectA != null)
{
record.PRobjectA[record.PRindexMap[0]] = pr.PRnewObj;
}
else
{
((Array) record.PRnewObj).SetValue(pr.PRnewObj, record.PRindexMap);
}
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue)
{
if (object.ReferenceEquals(record.PRarrayElementType, Converter.typeofString) || object.ReferenceEquals(pr.PRdtType, Converter.typeofString))
{
this.ParseString(pr, record);
if (record.PRobjectA != null)
{
record.PRobjectA[record.PRindexMap[0]] = pr.PRvalue;
}
else
{
((Array) record.PRnewObj).SetValue(pr.PRvalue, record.PRindexMap);
}
}
else if (record.PRisArrayVariant)
{
if (pr.PRkeyDt == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_ArrayTypeObject"));
}
object pRvalue = null;
if (object.ReferenceEquals(pr.PRdtType, Converter.typeofString))
{
this.ParseString(pr, record);
pRvalue = pr.PRvalue;
}
else if (object.ReferenceEquals(pr.PRdtTypeCode, InternalPrimitiveTypeE.Invalid))
{
this.CheckSerializable(pr.PRdtType);
if (this.IsRemoting && (this.formatterEnums.FEsecurityLevel != TypeFilterLevel.Full))
{
pRvalue = FormatterServices.GetSafeUninitializedObject(pr.PRdtType);
}
else
{
pRvalue = FormatterServices.GetUninitializedObject(pr.PRdtType);
}
}
else if (pr.PRvarValue != null)
{
pRvalue = pr.PRvarValue;
}
else
{
pRvalue = Converter.FromString(pr.PRvalue, pr.PRdtTypeCode);
}
if (record.PRobjectA != null)
{
record.PRobjectA[record.PRindexMap[0]] = pRvalue;
}
else
{
((Array) record.PRnewObj).SetValue(pRvalue, record.PRindexMap);
}
}
else if (record.PRprimitiveArray != null)
{
record.PRprimitiveArray.SetValue(pr.PRvalue, record.PRindexMap[0]);
}
else
{
object pRvarValue = null;
if (pr.PRvarValue != null)
{
pRvarValue = pr.PRvarValue;
}
else
{
pRvarValue = Converter.FromString(pr.PRvalue, record.PRarrayElementTypeCode);
}
if (record.PRobjectA != null)
{
record.PRobjectA[record.PRindexMap[0]] = pRvarValue;
}
else
{
((Array) record.PRnewObj).SetValue(pRvarValue, record.PRindexMap);
}
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Null)
{
record.PRmemberIndex += pr.PRnullCount - 1;
}
else
{
this.ParseError(pr, record);
}
record.PRmemberIndex++;
}
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);
}
private void ParseMemberEnd(ParseRecord pr)
{
switch (pr.PRmemberTypeEnum)
{
case InternalMemberTypeE.Field:
if (pr.PRmemberValueEnum != InternalMemberValueE.Nested)
{
break;
}
this.ParseObjectEnd(pr);
return;
case InternalMemberTypeE.Item:
this.ParseArrayMemberEnd(pr);
return;
default:
this.ParseError(pr, (ParseRecord) this.stack.Peek());
break;
}
}
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
}
Debug.Assert(record._name != null && record._memberNames != null && record._binaryTypeEnumA != null && record._typeInformationA != null && record._memberAssemIds != null);
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);
}
[System.Security.SecurityCritical] // auto-generated
private void ReadArrayAsBytes(ParseRecord pr)
{
if (pr.PRarrayElementTypeCode == InternalPrimitiveTypeE.Byte)
pr.PRnewObj = ReadBytes(pr.PRlengthA[0]);
else if (pr.PRarrayElementTypeCode == InternalPrimitiveTypeE.Char)
pr.PRnewObj = ReadChars(pr.PRlengthA[0]);
else
{
int typeLength = Converter.TypeLength(pr.PRarrayElementTypeCode);
pr.PRnewObj = Converter.CreatePrimitiveArray(pr.PRarrayElementTypeCode, pr.PRlengthA[0]);
//pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA[0]);
Contract.Assert((pr.PRnewObj != null),"[BinaryParser expected a Primitive Array]");
Array array = (Array)pr.PRnewObj;
int arrayOffset = 0;
if (byteBuffer == null)
byteBuffer = new byte[chunkSize];
while (arrayOffset < array.Length)
{
int numArrayItems = Math.Min(chunkSize/typeLength, array.Length-arrayOffset);
int bufferUsed = numArrayItems*typeLength;
ReadBytes(byteBuffer, 0, bufferUsed);
#if BIGENDIAN
// we know that we are reading a primitive type, so just do a simple swap
for (int i = 0; i < bufferUsed; i += typeLength)
{
for (int j = 0; j < typeLength / 2; j++)
{
byte tmp = byteBuffer[i + j];
byteBuffer[i + j] = byteBuffer[i + typeLength - 1 - j];
byteBuffer[i + typeLength - 1 - j] = tmp;
}
}
#endif
Buffer.InternalBlockCopy(byteBuffer, 0, array, arrayOffset*typeLength, bufferUsed);
arrayOffset += numArrayItems;
}
}
}
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;
Debug.Assert(record._lengthA != null);
switch (record._binaryArrayTypeEnum)
{
case BinaryArrayTypeEnum.Single:
case BinaryArrayTypeEnum.SingleOffset:
op._numItems = record._lengthA[0];
pr._arrayTypeEnum = InternalArrayTypeE.Single;
Debug.Assert(record._lowerBoundA != null);
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 SerializedStreamHeader element. This is the first element in the stream if present
private void ParseSerializedStreamHeader(ParseRecord pr)
{
SerTrace.Log( this, "SerializedHeader ",pr);
stack.Push(pr);
}
// Parse the SerializedStreamHeader element. This is the first element in the stream if present private void ParseSerializedStreamHeader(ParseRecord pr) => _stack !.Push(pr);
internal void CheckSecurity(ParseRecord pr)
{
InternalST.SoapAssert(pr!=null, "[BinaryObjectReader.CheckSecurity]pr!=null");
Type t = pr.PRdtType;
if (t != null && IsRemoting){
if (typeof(MarshalByRefObject).IsAssignableFrom(t))
throw new ArgumentException(String.Format(Environment.GetResourceString("Serialization_MBRAsMBV"), t.FullName));
}
//If we passed the security check, they can do whatever they'd like,
//so we'll just short-circuit this.
if (deserializationSecurityException==null) {
return;
}
// BaseTypes and Array of basetypes allowed
if (t != null)
{
if (t.IsPrimitive || t == Converter.typeofString)
return;
if (typeof(Enum).IsAssignableFrom(t))
return;
if (t.IsArray)
{
Type type = t.GetElementType();
if (type.IsPrimitive || type == Converter.typeofString)
return;
}
}
throw deserializationSecurityException;
}
// Parse the SerializedStreamHeader end element. This is the last element in the stream if present private void ParseSerializedStreamHeaderEnd(ParseRecord pr) => _stack !.Pop();
// End of object encountered in stream
private void ParseObjectEnd(ParseRecord pr)
{
SerTrace.Log( this, "ParseObjectEnd Entry ",pr.Trace());
ParseRecord objectPr = (ParseRecord)stack.Peek();
if (objectPr == null)
objectPr = pr;
//BCLDebug.Assert(objectPr != null, "[System.Runtime.Serialization.Formatters.ParseObjectEnd]objectPr != null");
SerTrace.Log( this, "ParseObjectEnd objectPr ",objectPr.Trace());
if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
SerTrace.Log( this, "ParseObjectEnd Top Object dtType ",objectPr.PRdtType);
if (objectPr.PRdtType == Converter.typeofString)
{
SerTrace.Log( this, "ParseObjectEnd Top String");
objectPr.PRnewObj = objectPr.PRvalue;
isTopObjectResolved = true;
topObject = objectPr.PRnewObj;
return;
}
}
stack.Pop();
ParseRecord parentPr = (ParseRecord)stack.Peek();
if (objectPr.PRobjectTypeEnum == InternalObjectTypeE.Array)
{
if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
SerTrace.Log( this, "ParseObjectEnd Top Object (Array) Resolved");
isTopObjectResolved = true;
topObject = objectPr.PRnewObj;
}
SerTrace.Log( this, "ParseArray RegisterObject ",objectPr.PRobjectId," ",objectPr.PRnewObj.GetType());
RegisterObject(objectPr.PRnewObj, objectPr, parentPr);
return;
}
objectPr.PRobjectInfo.PopulateObjectMembers(objectPr.PRnewObj, objectPr.PRmemberData);
// Registration is after object is populated
if ((!objectPr.PRisRegistered) && (objectPr.PRobjectId > 0))
{
SerTrace.Log( this, "ParseObject Register Object ",objectPr.PRobjectId," ",objectPr.PRnewObj.GetType());
RegisterObject(objectPr.PRnewObj, objectPr, parentPr);
}
if (objectPr.PRisValueTypeFixup)
{
SerTrace.Log( this, "ParseObjectEnd ValueTypeFixup ",objectPr.PRnewObj.GetType());
ValueFixup fixup = (ValueFixup)ValueFixupStack.Pop(); //Value fixup
fixup.Fixup(objectPr, parentPr); // Value fixup
}
if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
SerTrace.Log( this, "ParseObjectEnd Top Object Resolved ",objectPr.PRnewObj.GetType());
isTopObjectResolved = true;
topObject = objectPr.PRnewObj;
}
objectPr.PRobjectInfo.ObjectEnd();
SerTrace.Log( this, "ParseObjectEnd Exit ",objectPr.PRnewObj.GetType()," id: ",objectPr.PRobjectId);
}
// Styled ParseError output
private void ParseError(ParseRecord processing, ParseRecord onStack)
{
throw new SerializationException(SR.Format(SR.Serialization_ParseError, onStack._name + " " + onStack._parseTypeEnum + " " + processing._name + " " + processing._parseTypeEnum));
}
// Builds a map for each item in an incoming rectangle array. The map specifies where the item is placed in the output Array Object
private void NextRectangleMap(ParseRecord pr)
{
// For each invocation, calculate the next rectangular array position
// example
// indexMap 0 [0,0,0]
// indexMap 1 [0,0,1]
// indexMap 2 [0,0,2]
// indexMap 3 [0,0,3]
// indexMap 4 [0,1,0]
for (int irank = pr.PRrank-1; irank>-1; irank--)
{
// Find the current or lower dimension which can be incremented.
if (pr.PRrectangularMap[irank] < pr.PRlengthA[irank]-1)
{
// The current dimension is at maximum. Increase the next lower dimension by 1
pr.PRrectangularMap[irank]++;
if (irank < pr.PRrank-1)
{
// The current dimension and higher dimensions are zeroed.
for (int i = irank+1; i<pr.PRrank; i++)
pr.PRrectangularMap[i] = 0;
}
Array.Copy(pr.PRrectangularMap, pr.PRindexMap, pr.PRrank);
break;
}
}
}
// New object encountered in stream
private void ParseObject(ParseRecord pr)
{
if (!_fullDeserialization)
{
InitFullDeserialization();
}
if (pr._objectPositionEnum == InternalObjectPositionE.Top)
{
_topId = pr._objectId;
}
if (pr._parseTypeEnum == InternalParseTypeE.Object)
{
_stack.Push(pr); // Nested objects member names are already on stack
}
if (pr._objectTypeEnum == InternalObjectTypeE.Array)
{
ParseArray(pr);
return;
}
// If the Type is null, this means we have a typeload issue
// mark the object with TypeLoadExceptionHolder
if (pr._dtType == null)
{
pr._newObj = new TypeLoadExceptionHolder(pr._keyDt);
return;
}
if (ReferenceEquals(pr._dtType, Converter.s_typeofString))
{
// String as a top level object
if (pr._value != null)
{
pr._newObj = pr._value;
if (pr._objectPositionEnum == InternalObjectPositionE.Top)
{
TopObject = pr._newObj;
return;
}
else
{
_stack.Pop();
RegisterObject(pr._newObj, pr, (ParseRecord)_stack.Peek());
return;
}
}
else
{
// xml Doesn't have the value until later
return;
}
}
else
{
CheckSerializable(pr._dtType);
pr._newObj = FormatterServices.GetUninitializedObject(pr._dtType);
// Run the OnDeserializing methods
_objectManager.RaiseOnDeserializingEvent(pr._newObj);
}
if (pr._newObj == null)
{
throw new SerializationException(SR.Format(SR.Serialization_TopObjectInstantiate, pr._dtType));
}
if (pr._objectPositionEnum == InternalObjectPositionE.Top)
{
TopObject = pr._newObj;
}
if (pr._objectInfo == null)
{
pr._objectInfo = ReadObjectInfo.Create(pr._dtType, _surrogates, _context, _objectManager, _serObjectInfoInit, _formatterConverter, _isSimpleAssembly);
}
}
private void ParseArrayMemberEnd(ParseRecord pr)
{
SerTrace.Log( this, "ParseArrayMemberEnd");
// If this is a nested array object, then pop the stack
if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
ParseObjectEnd(pr);
}
}
// Array object encountered in stream
private void ParseArray(ParseRecord pr)
{
long genId = pr._objectId;
if (pr._arrayTypeEnum == InternalArrayTypeE.Base64)
{
// ByteArray
pr._newObj = pr._value.Length > 0 ?
Convert.FromBase64String(pr._value) :
Array.Empty <byte>();
if (_stack.Peek() == pr)
{
_stack.Pop();
}
if (pr._objectPositionEnum == InternalObjectPositionE.Top)
{
TopObject = pr._newObj;
}
ParseRecord parentPr = (ParseRecord)_stack.Peek();
// Base64 can be registered at this point because it is populated
RegisterObject(pr._newObj, pr, parentPr);
}
else if ((pr._newObj != null) && Converter.IsWriteAsByteArray(pr._arrayElementTypeCode))
{
// Primtive typed Array has already been read
if (pr._objectPositionEnum == InternalObjectPositionE.Top)
{
TopObject = pr._newObj;
}
ParseRecord parentPr = (ParseRecord)_stack.Peek();
// Primitive typed array can be registered at this point because it is populated
RegisterObject(pr._newObj, pr, parentPr);
}
else if ((pr._arrayTypeEnum == InternalArrayTypeE.Jagged) || (pr._arrayTypeEnum == InternalArrayTypeE.Single))
{
// Multidimensional jagged array or single array
bool couldBeValueType = true;
if ((pr._lowerBoundA == null) || (pr._lowerBoundA[0] == 0))
{
if (ReferenceEquals(pr._arrayElementType, Converter.s_typeofString))
{
pr._objectA = new string[pr._lengthA[0]];
pr._newObj = pr._objectA;
couldBeValueType = false;
}
else if (ReferenceEquals(pr._arrayElementType, Converter.s_typeofObject))
{
pr._objectA = new object[pr._lengthA[0]];
pr._newObj = pr._objectA;
couldBeValueType = false;
}
else if (pr._arrayElementType != null)
{
pr._newObj = Array.CreateInstance(pr._arrayElementType, pr._lengthA[0]);
}
pr._isLowerBound = false;
}
else
{
if (pr._arrayElementType != null)
{
pr._newObj = Array.CreateInstance(pr._arrayElementType, pr._lengthA, pr._lowerBoundA);
}
pr._isLowerBound = true;
}
if (pr._arrayTypeEnum == InternalArrayTypeE.Single)
{
if (!pr._isLowerBound && (Converter.IsWriteAsByteArray(pr._arrayElementTypeCode)))
{
pr._primitiveArray = new PrimitiveArray(pr._arrayElementTypeCode, (Array)pr._newObj);
}
else if (couldBeValueType && pr._arrayElementType != null)
{
if (!pr._arrayElementType.IsValueType && !pr._isLowerBound)
{
pr._objectA = (object[])pr._newObj;
}
}
}
pr._indexMap = new int[1];
}
else if (pr._arrayTypeEnum == InternalArrayTypeE.Rectangular)
{
// Rectangle array
pr._isLowerBound = false;
if (pr._lowerBoundA != null)
{
for (int i = 0; i < pr._rank; i++)
{
if (pr._lowerBoundA[i] != 0)
{
pr._isLowerBound = true;
}
}
}
if (pr._arrayElementType != null)
{
pr._newObj = !pr._isLowerBound ?
Array.CreateInstance(pr._arrayElementType, pr._lengthA) :
Array.CreateInstance(pr._arrayElementType, pr._lengthA, pr._lowerBoundA);
}
// Calculate number of items
int sum = 1;
for (int i = 0; i < pr._rank; i++)
{
sum = sum * pr._lengthA[i];
}
pr._indexMap = new int[pr._rank];
pr._rectangularMap = new int[pr._rank];
pr._linearlength = sum;
}
else
{
throw new SerializationException(SR.Format(SR.Serialization_ArrayType, pr._arrayTypeEnum));
}
}
internal void Fixup(ParseRecord record, ParseRecord parent)
{
object obj = record._newObj;
switch (_valueFixupEnum)
{
case ValueFixupEnum.Array:
_arrayObj.SetValue(obj, _indexMap);
break;
case ValueFixupEnum.Header:
Type type = typeof(Header);
if (_valueInfo == null)
{
MemberInfo[] valueInfos = type.GetMember("Value");
if (valueInfos.Length != 1)
{
throw new SerializationException(SR.Format(SR.Serialization_HeaderReflection, valueInfos.Length));
}
_valueInfo = valueInfos[0];
}
FormatterServices.SerializationSetValue(_valueInfo, _header, obj);
break;
case ValueFixupEnum.Member:
if (_objectInfo._isSi)
{
_objectInfo._objectManager.RecordDelayedFixup(parent._objectId, _memberName, record._objectId);
}
else
{
MemberInfo memberInfo = _objectInfo.GetMemberInfo(_memberName);
if (memberInfo != null)
{
_objectInfo._objectManager.RecordFixup(parent._objectId, memberInfo, record._objectId);
}
}
break;
}
}
// Array object item encountered in stream
private void ParseArrayMember(ParseRecord pr)
{
ParseRecord objectPr = (ParseRecord)_stack.Peek();
// Set up for inserting value into correct array position
if (objectPr._arrayTypeEnum == InternalArrayTypeE.Rectangular)
{
if (objectPr._memberIndex > 0)
{
NextRectangleMap(objectPr); // Rectangle array, calculate position in array
}
if (objectPr._isLowerBound)
{
for (int i = 0; i < objectPr._rank; i++)
{
objectPr._indexMap[i] = objectPr._rectangularMap[i] + objectPr._lowerBoundA[i];
}
}
}
else
{
objectPr._indexMap[0] = !objectPr._isLowerBound ?
objectPr._memberIndex : // Zero based array
objectPr._lowerBoundA[0] + objectPr._memberIndex; // Lower Bound based array
}
// Set Array element according to type of element
if (pr._memberValueEnum == InternalMemberValueE.Reference)
{
// Object Reference
// See if object has already been instantiated
object refObj = _objectManager.GetObject(pr._idRef);
if (refObj == null)
{
// Object not instantiated
// Array fixup manager
int[] fixupIndex = new int[objectPr._rank];
Array.Copy(objectPr._indexMap, 0, fixupIndex, 0, objectPr._rank);
_objectManager.RecordArrayElementFixup(objectPr._objectId, fixupIndex, pr._idRef);
}
else
{
if (objectPr._objectA != null)
{
objectPr._objectA[objectPr._indexMap[0]] = refObj;
}
else
{
((Array)objectPr._newObj).SetValue(refObj, objectPr._indexMap); // Object has been instantiated
}
}
}
else if (pr._memberValueEnum == InternalMemberValueE.Nested)
{
//Set up dtType for ParseObject
if (pr._dtType == null)
{
pr._dtType = objectPr._arrayElementType;
}
ParseObject(pr);
_stack.Push(pr);
if (objectPr._arrayElementType != null)
{
if ((objectPr._arrayElementType.IsValueType) && (pr._arrayElementTypeCode == InternalPrimitiveTypeE.Invalid))
{
pr._isValueTypeFixup = true; //Valuefixup
ValueFixupStack.Push(new ValueFixup((Array)objectPr._newObj, objectPr._indexMap)); //valuefixup
}
else
{
if (objectPr._objectA != null)
{
objectPr._objectA[objectPr._indexMap[0]] = pr._newObj;
}
else
{
((Array)objectPr._newObj).SetValue(pr._newObj, objectPr._indexMap);
}
}
}
}
else if (pr._memberValueEnum == InternalMemberValueE.InlineValue)
{
if ((ReferenceEquals(objectPr._arrayElementType, Converter.s_typeofString)) || (ReferenceEquals(pr._dtType, Converter.s_typeofString)))
{
// String in either a string array, or a string element of an object array
ParseString(pr, objectPr);
if (objectPr._objectA != null)
{
objectPr._objectA[objectPr._indexMap[0]] = pr._value;
}
else
{
((Array)objectPr._newObj).SetValue(pr._value, objectPr._indexMap);
}
}
else if (objectPr._isArrayVariant)
{
// Array of type object
if (pr._keyDt == null)
{
throw new SerializationException(SR.Serialization_ArrayTypeObject);
}
object var = null;
if (ReferenceEquals(pr._dtType, Converter.s_typeofString))
{
ParseString(pr, objectPr);
var = pr._value;
}
else if (ReferenceEquals(pr._dtTypeCode, InternalPrimitiveTypeE.Invalid))
{
CheckSerializable(pr._dtType);
// Not nested and invalid, so it is an empty object
var = FormatterServices.GetUninitializedObject(pr._dtType);
}
else
{
var = pr._varValue != null ?
pr._varValue :
Converter.FromString(pr._value, pr._dtTypeCode);
}
if (objectPr._objectA != null)
{
objectPr._objectA[objectPr._indexMap[0]] = var;
}
else
{
((Array)objectPr._newObj).SetValue(var, objectPr._indexMap); // Primitive type
}
}
else
{
// Primitive type
if (objectPr._primitiveArray != null)
{
// Fast path for Soap primitive arrays. Binary was handled in the BinaryParser
objectPr._primitiveArray.SetValue(pr._value, objectPr._indexMap[0]);
}
else
{
object var = pr._varValue != null ?
pr._varValue :
Converter.FromString(pr._value, objectPr._arrayElementTypeCode);
if (objectPr._objectA != null)
{
objectPr._objectA[objectPr._indexMap[0]] = var;
}
else
{
((Array)objectPr._newObj).SetValue(var, objectPr._indexMap); // Primitive type
}
}
}
}
else if (pr._memberValueEnum == InternalMemberValueE.Null)
{
objectPr._memberIndex += pr._consecutiveNullArrayEntryCount - 1; //also incremented again below
}
else
{
ParseError(pr, objectPr);
}
objectPr._memberIndex++;
}
private void ParseSerializedStreamHeaderEnd(ParseRecord pr)
{
this.stack.Pop();
}
// Object member encountered in stream
private void ParseMember(ParseRecord pr)
{
ParseRecord objectPr = (ParseRecord)_stack.Peek();
string objName = objectPr?._name;
switch (pr._memberTypeEnum)
{
case InternalMemberTypeE.Item:
ParseArrayMember(pr);
return;
case InternalMemberTypeE.Field:
break;
}
//if ((pr.PRdtType == null) && !objectPr.PRobjectInfo.isSi)
if (pr._dtType == null && objectPr._objectInfo._isTyped)
{
pr._dtType = objectPr._objectInfo.GetType(pr._name);
if (pr._dtType != null)
{
pr._dtTypeCode = Converter.ToCode(pr._dtType);
}
}
if (pr._memberValueEnum == InternalMemberValueE.Null)
{
// Value is Null
objectPr._objectInfo.AddValue(pr._name, null, ref objectPr._si, ref objectPr._memberData);
}
else if (pr._memberValueEnum == InternalMemberValueE.Nested)
{
ParseObject(pr);
_stack.Push(pr);
if ((pr._objectInfo != null) && pr._objectInfo._objectType != null && (pr._objectInfo._objectType.IsValueType))
{
pr._isValueTypeFixup = true; //Valuefixup
ValueFixupStack.Push(new ValueFixup(objectPr._newObj, pr._name, objectPr._objectInfo)); //valuefixup
}
else
{
objectPr._objectInfo.AddValue(pr._name, pr._newObj, ref objectPr._si, ref objectPr._memberData);
}
}
else if (pr._memberValueEnum == InternalMemberValueE.Reference)
{
// See if object has already been instantiated
object refObj = _objectManager.GetObject(pr._idRef);
if (refObj == null)
{
objectPr._objectInfo.AddValue(pr._name, null, ref objectPr._si, ref objectPr._memberData);
objectPr._objectInfo.RecordFixup(objectPr._objectId, pr._name, pr._idRef); // Object not instantiated
}
else
{
objectPr._objectInfo.AddValue(pr._name, refObj, ref objectPr._si, ref objectPr._memberData);
}
}
else if (pr._memberValueEnum == InternalMemberValueE.InlineValue)
{
// Primitive type or String
if (ReferenceEquals(pr._dtType, Converter.s_typeofString))
{
ParseString(pr, objectPr);
objectPr._objectInfo.AddValue(pr._name, pr._value, ref objectPr._si, ref objectPr._memberData);
}
else if (pr._dtTypeCode == InternalPrimitiveTypeE.Invalid)
{
// The member field was an object put the value is Inline either bin.Base64 or invalid
if (pr._arrayTypeEnum == InternalArrayTypeE.Base64)
{
objectPr._objectInfo.AddValue(pr._name, Convert.FromBase64String(pr._value), ref objectPr._si, ref objectPr._memberData);
}
else if (ReferenceEquals(pr._dtType, Converter.s_typeofObject))
{
throw new SerializationException(SR.Format(SR.Serialization_TypeMissing, pr._name));
}
else
{
ParseString(pr, objectPr); // Register the object if it has an objectId
// Object Class with no memberInfo data
// only special case where AddValue is needed?
if (ReferenceEquals(pr._dtType, Converter.s_typeofSystemVoid))
{
objectPr._objectInfo.AddValue(pr._name, pr._dtType, ref objectPr._si, ref objectPr._memberData);
}
else if (objectPr._objectInfo._isSi)
{
// ISerializable are added as strings, the conversion to type is done by the
// ISerializable object
objectPr._objectInfo.AddValue(pr._name, pr._value, ref objectPr._si, ref objectPr._memberData);
}
}
}
else
{
object var = pr._varValue != null ?
pr._varValue :
Converter.FromString(pr._value, pr._dtTypeCode);
objectPr._objectInfo.AddValue(pr._name, var, ref objectPr._si, ref objectPr._memberData);
}
}
else
{
ParseError(pr, objectPr);
}
}
private void RegisterObject(object obj, ParseRecord pr, ParseRecord objectPr)
{
this.RegisterObject(obj, pr, objectPr, false);
}
internal ParseRecord Copy()
{
ParseRecord newPr = new ParseRecord();
// Enums
newPr.PRparseTypeEnum = PRparseTypeEnum;
newPr.PRobjectTypeEnum = PRobjectTypeEnum;
newPr.PRarrayTypeEnum = PRarrayTypeEnum;
newPr.PRmemberTypeEnum = PRmemberTypeEnum;
newPr.PRmemberValueEnum = PRmemberValueEnum;
newPr.PRobjectPositionEnum = PRobjectPositionEnum;
// Object
newPr.PRname = PRname;
// Value
newPr.PRvalue = PRvalue;
// dt attribute
newPr.PRkeyDt = PRkeyDt;
newPr.PRdtType = PRdtType;
newPr.PRdtTypeCode = PRdtTypeCode;
newPr.PRisEnum = PRisEnum;
// Object ID
newPr.PRobjectId = PRobjectId;
// Reference ID
newPr.PRidRef = PRidRef;
// Array
// Array Element Type
newPr.PRarrayElementTypeString = PRarrayElementTypeString;
newPr.PRarrayElementType = PRarrayElementType;
newPr.PRisArrayVariant = PRisArrayVariant;
newPr.PRarrayElementTypeCode = PRarrayElementTypeCode;
// Parsed array information
newPr.PRrank = PRrank;
newPr.PRlengthA = PRlengthA;
newPr.PRpositionA = PRpositionA;
newPr.PRlowerBoundA = PRlowerBoundA;
newPr.PRupperBoundA = PRupperBoundA;
// Array map for placing array elements in array
newPr.PRindexMap = PRindexMap;
newPr.PRmemberIndex = PRmemberIndex;
newPr.PRlinearlength = PRlinearlength;
newPr.PRrectangularMap = PRrectangularMap;
newPr.PRisLowerBound = PRisLowerBound;
// SerializedStreamHeader information
newPr.PRtopId = PRtopId;
newPr.PRheaderId = PRheaderId;
// ValueType Fixup needed
newPr.PRisValueTypeFixup = PRisValueTypeFixup;
newPr.PRnewObj = PRnewObj;
newPr.PRobjectA = PRobjectA;
newPr.PRprimitiveArray = PRprimitiveArray;
newPr.PRobjectInfo = PRobjectInfo;
newPr.PRisRegistered = PRisRegistered;
newPr.PRnullCount = PRnullCount;
newPr.PRmemberData = PRmemberData;
newPr.PRsi = PRsi;
return(newPr);
}
private void NextRectangleMap(ParseRecord pr)
{
for (int i = pr.PRrank - 1; i > -1; i--)
{
if (pr.PRrectangularMap[i] < (pr.PRlengthA[i] - 1))
{
pr.PRrectangularMap[i]++;
if (i < (pr.PRrank - 1))
{
for (int j = i + 1; j < pr.PRrank; j++)
{
pr.PRrectangularMap[j] = 0;
}
}
Array.Copy(pr.PRrectangularMap, pr.PRindexMap, pr.PRrank);
return;
}
}
}
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 ParseArray(ParseRecord pr)
{
long pRobjectId = pr.PRobjectId;
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
{
if (pr.PRvalue.Length > 0)
{
pr.PRnewObj = Convert.FromBase64String(pr.PRvalue);
}
else
{
pr.PRnewObj = new byte[0];
}
if (this.stack.Peek() == pr)
{
this.stack.Pop();
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = pr.PRnewObj;
}
ParseRecord objectPr = (ParseRecord) this.stack.Peek();
this.RegisterObject(pr.PRnewObj, pr, objectPr);
}
else if ((pr.PRnewObj != null) && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
{
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = pr.PRnewObj;
}
ParseRecord record2 = (ParseRecord) this.stack.Peek();
this.RegisterObject(pr.PRnewObj, pr, record2);
}
else if ((pr.PRarrayTypeEnum == InternalArrayTypeE.Jagged) || (pr.PRarrayTypeEnum == InternalArrayTypeE.Single))
{
bool flag = true;
if ((pr.PRlowerBoundA == null) || (pr.PRlowerBoundA[0] == 0))
{
if (object.ReferenceEquals(pr.PRarrayElementType, Converter.typeofString))
{
pr.PRobjectA = new string[pr.PRlengthA[0]];
pr.PRnewObj = pr.PRobjectA;
flag = false;
}
else if (object.ReferenceEquals(pr.PRarrayElementType, Converter.typeofObject))
{
pr.PRobjectA = new object[pr.PRlengthA[0]];
pr.PRnewObj = pr.PRobjectA;
flag = false;
}
else if (pr.PRarrayElementType != null)
{
pr.PRnewObj = Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA[0]);
}
pr.PRisLowerBound = false;
}
else
{
if (pr.PRarrayElementType != null)
{
pr.PRnewObj = Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
}
pr.PRisLowerBound = true;
}
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Single)
{
if (!pr.PRisLowerBound && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
{
pr.PRprimitiveArray = new PrimitiveArray(pr.PRarrayElementTypeCode, (Array) pr.PRnewObj);
}
else if ((flag && (pr.PRarrayElementType != null)) && (!pr.PRarrayElementType.IsValueType && !pr.PRisLowerBound))
{
pr.PRobjectA = (object[]) pr.PRnewObj;
}
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Headers)
{
this.headers = (Header[]) pr.PRnewObj;
}
pr.PRindexMap = new int[1];
}
else
{
if (pr.PRarrayTypeEnum != InternalArrayTypeE.Rectangular)
{
throw new SerializationException(Environment.GetResourceString("Serialization_ArrayType", new object[] { pr.PRarrayTypeEnum }));
}
pr.PRisLowerBound = false;
if (pr.PRlowerBoundA != null)
{
for (int j = 0; j < pr.PRrank; j++)
{
if (pr.PRlowerBoundA[j] != 0)
{
pr.PRisLowerBound = true;
}
}
}
if (pr.PRarrayElementType != null)
{
if (!pr.PRisLowerBound)
{
pr.PRnewObj = Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA);
}
else
{
pr.PRnewObj = Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
}
}
int num2 = 1;
for (int i = 0; i < pr.PRrank; i++)
{
num2 *= pr.PRlengthA[i];
}
pr.PRindexMap = new int[pr.PRrank];
pr.PRrectangularMap = new int[pr.PRrank];
pr.PRlinearlength = num2;
}
this.CheckSecurity(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 ParseArrayMemberEnd(ParseRecord pr)
{
if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
this.ParseObjectEnd(pr);
}
}
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 void ParseMember(ParseRecord pr)
{
ParseRecord parentPr = (ParseRecord) this.stack.Peek();
if (parentPr != null)
{
string pRname = parentPr.PRname;
}
switch (pr.PRmemberTypeEnum)
{
case InternalMemberTypeE.Item:
this.ParseArrayMember(pr);
return;
}
if ((pr.PRdtType == null) && parentPr.PRobjectInfo.isTyped)
{
pr.PRdtType = parentPr.PRobjectInfo.GetType(pr.PRname);
if (pr.PRdtType != null)
{
pr.PRdtTypeCode = Converter.ToCode(pr.PRdtType);
}
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Null)
{
parentPr.PRobjectInfo.AddValue(pr.PRname, null, ref parentPr.PRsi, ref parentPr.PRmemberData);
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
this.ParseObject(pr);
this.stack.Push(pr);
if (((pr.PRobjectInfo != null) && (pr.PRobjectInfo.objectType != null)) && pr.PRobjectInfo.objectType.IsValueType)
{
pr.PRisValueTypeFixup = true;
this.ValueFixupStack.Push(new ValueFixup(parentPr.PRnewObj, pr.PRname, parentPr.PRobjectInfo));
}
else
{
parentPr.PRobjectInfo.AddValue(pr.PRname, pr.PRnewObj, ref parentPr.PRsi, ref parentPr.PRmemberData);
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Reference)
{
object obj2 = this.m_objectManager.GetObject(pr.PRidRef);
if (obj2 == null)
{
parentPr.PRobjectInfo.AddValue(pr.PRname, null, ref parentPr.PRsi, ref parentPr.PRmemberData);
parentPr.PRobjectInfo.RecordFixup(parentPr.PRobjectId, pr.PRname, pr.PRidRef);
}
else
{
parentPr.PRobjectInfo.AddValue(pr.PRname, obj2, ref parentPr.PRsi, ref parentPr.PRmemberData);
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue)
{
if (object.ReferenceEquals(pr.PRdtType, Converter.typeofString))
{
this.ParseString(pr, parentPr);
parentPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue, ref parentPr.PRsi, ref parentPr.PRmemberData);
}
else if (pr.PRdtTypeCode != InternalPrimitiveTypeE.Invalid)
{
object pRvarValue = null;
if (pr.PRvarValue != null)
{
pRvarValue = pr.PRvarValue;
}
else
{
pRvarValue = Converter.FromString(pr.PRvalue, pr.PRdtTypeCode);
}
parentPr.PRobjectInfo.AddValue(pr.PRname, pRvarValue, ref parentPr.PRsi, ref parentPr.PRmemberData);
}
else if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
{
parentPr.PRobjectInfo.AddValue(pr.PRname, Convert.FromBase64String(pr.PRvalue), ref parentPr.PRsi, ref parentPr.PRmemberData);
}
else
{
if (object.ReferenceEquals(pr.PRdtType, Converter.typeofObject))
{
throw new SerializationException(Environment.GetResourceString("Serialization_TypeMissing", new object[] { pr.PRname }));
}
this.ParseString(pr, parentPr);
if (object.ReferenceEquals(pr.PRdtType, Converter.typeofSystemVoid))
{
parentPr.PRobjectInfo.AddValue(pr.PRname, pr.PRdtType, ref parentPr.PRsi, ref parentPr.PRmemberData);
}
else if (parentPr.PRobjectInfo.isSi)
{
parentPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue, ref parentPr.PRsi, ref parentPr.PRmemberData);
}
}
}
else
{
this.ParseError(pr, parentPr);
}
}
private void ParseSerializedStreamHeader(ParseRecord pr)
{
this.stack.Push(pr);
}
internal void CheckSecurity(ParseRecord pr)
{
Type pRdtType = pr.PRdtType;
if ((pRdtType != null) && this.IsRemoting)
{
if (typeof(MarshalByRefObject).IsAssignableFrom(pRdtType))
{
throw new ArgumentException(Environment.GetResourceString("Serialization_MBRAsMBV", new object[] { pRdtType.FullName }));
}
FormatterServices.CheckTypeSecurity(pRdtType, this.formatterEnums.FEsecurityLevel);
}
}
private void ParseSerializedStreamHeaderEnd(ParseRecord pr)
{
this.stack.Pop();
}
private void ParseObjectEnd(ParseRecord pr)
{
ParseRecord record = (ParseRecord) this.stack.Peek();
if (record == null)
{
record = pr;
}
if ((record.PRobjectPositionEnum == InternalObjectPositionE.Top) && object.ReferenceEquals(record.PRdtType, Converter.typeofString))
{
record.PRnewObj = record.PRvalue;
this.TopObject = record.PRnewObj;
}
else
{
this.stack.Pop();
ParseRecord objectPr = (ParseRecord) this.stack.Peek();
if (record.PRnewObj != null)
{
if (record.PRobjectTypeEnum == InternalObjectTypeE.Array)
{
if (record.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = record.PRnewObj;
}
this.RegisterObject(record.PRnewObj, record, objectPr);
}
else
{
record.PRobjectInfo.PopulateObjectMembers(record.PRnewObj, record.PRmemberData);
if (!record.PRisRegistered && (record.PRobjectId > 0L))
{
this.RegisterObject(record.PRnewObj, record, objectPr);
}
if (record.PRisValueTypeFixup)
{
((ValueFixup) this.ValueFixupStack.Pop()).Fixup(record, objectPr);
}
if (record.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = record.PRnewObj;
}
record.PRobjectInfo.ObjectEnd();
}
}
}
}
private void RegisterObject(object obj, ParseRecord pr, ParseRecord objectPr)
{
this.RegisterObject(obj, pr, objectPr, false);
}
private void ReadArrayAsBytes(ParseRecord pr)
{
if (pr._arrayElementTypeCode == InternalPrimitiveTypeE.Byte)
{
pr._newObj = ReadBytes(pr._lengthA[0]);
}
else if (pr._arrayElementTypeCode == InternalPrimitiveTypeE.Char)
{
pr._newObj = ReadChars(pr._lengthA[0]);
}
else
{
int typeLength = Converter.TypeLength(pr._arrayElementTypeCode);
pr._newObj = Converter.CreatePrimitiveArray(pr._arrayElementTypeCode, pr._lengthA[0]);
Debug.Assert((pr._newObj != null), "[BinaryParser expected a Primitive Array]");
Array array = (Array)pr._newObj;
int arrayOffset = 0;
if (_byteBuffer == null)
{
_byteBuffer = new byte[ChunkSize];
}
while (arrayOffset < array.Length)
{
int numArrayItems = Math.Min(ChunkSize / typeLength, array.Length - arrayOffset);
int bufferUsed = numArrayItems * typeLength;
ReadBytes(_byteBuffer, 0, bufferUsed);
if (!BitConverter.IsLittleEndian)
{
// we know that we are reading a primitive type, so just do a simple swap
Debug.Fail("Re-review this code if/when we start running on big endian systems");
for (int i = 0; i < bufferUsed; i += typeLength)
{
for (int j = 0; j < typeLength / 2; j++)
{
byte tmp = _byteBuffer[i + j];
_byteBuffer[i + j] = _byteBuffer[i + typeLength - 1 - j];
_byteBuffer[i + typeLength - 1 - j] = tmp;
}
}
}
Buffer.BlockCopy(_byteBuffer, 0, array, arrayOffset * typeLength, bufferUsed);
arrayOffset += numArrayItems;
}
}
}
private void ReadObject()
{
SerTrace.Log(this, "ReadObject");
if (binaryObject == null)
{
binaryObject = new BinaryObject();
}
binaryObject.Read(this);
binaryObject.Dump();
ObjectMap objectMap = (ObjectMap)ObjectMapIdTable[binaryObject.mapId];
if (objectMap == null)
{
throw new SerializationException(String.Format(Environment.GetResourceString("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
SerTrace.Log(this, "ReadObject non-nested ");
op.name = objectMap.objectName;
pr.PRparseTypeEnum = InternalParseTypeE.Object;
op.memberValueEnum = InternalMemberValueE.Empty;
}
else
{
// Nested Object
SerTrace.Log(this, "ReadObject nested ");
pr.PRparseTypeEnum = InternalParseTypeE.Member;
pr.PRmemberValueEnum = InternalMemberValueE.Nested;
op.memberValueEnum = InternalMemberValueE.Nested;
switch (objectOp.objectTypeEnum)
{
case InternalObjectTypeE.Object:
pr.PRname = objectOp.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(String.Format(Environment.GetResourceString("Serialization_Map"), ((Enum)objectOp.objectTypeEnum).ToString()));
}
}
pr.PRobjectId = objectReader.GetId((long)binaryObject.objectId);
SerTrace.Log(this, "ReadObject binaryObject.objectId ", pr.PRobjectId);
pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData);
if (pr.PRobjectId == topId)
{
pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
}
pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
pr.PRkeyDt = objectMap.objectName;
pr.PRdtType = objectMap.objectType;
pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
objectReader.Parse(pr);
}
