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); } }
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 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 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); }