The Labs \ Source Viewer \ SSCLI \ System.Runtime.Serialization.Formatters.Binary \ __BinaryParser

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. /*============================================================
  16. **
  17. ** Class: BinaryParser
  18. **
  19. **
  20. ** Purpose: Parses Binary Stream
  21. **
  22. **
  23. ===========================================================*/
  24. namespace System.Runtime.Serialization.Formatters.Binary
  25. {
  26.    
  27.     using System;
  28.     using System.IO;
  29.     using System.Collections;
  30.     using System.Reflection;
  31.     using System.Globalization;
  32.     using System.Runtime.Serialization.Formatters;
  33.     using System.Threading;
  34.     using System.Runtime.Remoting;
  35.     using System.Runtime.Serialization;
  36.     using System.Text;
  37.    
  38.     internal sealed class __BinaryParser
  39.     {
  40.         internal ObjectReader objectReader;
  41.         internal Stream input;
  42.         internal long topId;
  43.         internal long headerId;
  44.         internal SizedArray objectMapIdTable;
  45.         internal SizedArray assemIdToAssemblyTable;
  46.         // Used to hold assembly information
  47.         internal SerStack stack = new SerStack("ObjectProgressStack");
  48.        
  49.         internal BinaryTypeEnum expectedType = BinaryTypeEnum.ObjectUrt;
  50.         internal object expectedTypeInformation;
  51.         internal ParseRecord PRS;
  52.        
  53.         private BinaryAssemblyInfo systemAssemblyInfo;
  54.         private BinaryReader dataReader;
  55.         private static Encoding encoding = new UTF8Encoding(false, true);
  56.        
  57.         private SerStack opPool;
  58.        
  59.         internal __BinaryParser(Stream stream, ObjectReader objectReader)
  60.         {
  61.             input = stream;
  62.             this.objectReader = objectReader;
  63.             dataReader = new BinaryReader(input, encoding);
  64.         }
  65.        
  66.         internal BinaryAssemblyInfo SystemAssemblyInfo {
  67.             get {
  68.                 if (systemAssemblyInfo == null)
  69.                     systemAssemblyInfo = new BinaryAssemblyInfo(Converter.urtAssemblyString, Converter.urtAssembly);
  70.                 return systemAssemblyInfo;
  71.             }
  72.         }
  73.        
  74.         internal SizedArray ObjectMapIdTable {
  75.             get {
  76.                 if (objectMapIdTable == null)
  77.                     objectMapIdTable = new SizedArray();
  78.                
  79.                 return objectMapIdTable;
  80.             }
  81.         }
  82.        
  83.         internal SizedArray AssemIdToAssemblyTable {
  84.             get {
  85.                 if (assemIdToAssemblyTable == null) {
  86.                     assemIdToAssemblyTable = new SizedArray(2);
  87.                 }
  88.                 return assemIdToAssemblyTable;
  89.             }
  90.         }
  91.        
  92.         internal ParseRecord prs {
  93.             get {
  94.                 if (PRS == null)
  95.                     PRS = new ParseRecord();
  96.                 return PRS;
  97.             }
  98.         }
  99.        
  100. /*
  101. * Parse the input
  102. * Reads each record from the input stream. If the record is a primitive type (A number)
  103. *  then it doesn't have a BinaryHeaderEnum byte. For this case the expected type
  104. *  has been previously set to Primitive
  105. * @internalonly
  106. */       
  107.         internal void Run()
  108.         {
  109.             try {
  110.                 bool isLoop = true;
  111.                 ReadBegin();
  112.                 ReadSerializationHeaderRecord();
  113.                 while (isLoop) {
  114.                     SerTrace.Log(this, "Run loop ", ((Enum)expectedType).ToString());
  115.                     BinaryHeaderEnum binaryHeaderEnum = BinaryHeaderEnum.Object;
  116.                     switch (expectedType) {
  117.                         case BinaryTypeEnum.ObjectUrt:
  118.                         case BinaryTypeEnum.ObjectUser:
  119.                         case BinaryTypeEnum.String:
  120.                         case BinaryTypeEnum.Object:
  121.                         case BinaryTypeEnum.ObjectArray:
  122.                         case BinaryTypeEnum.StringArray:
  123.                         case BinaryTypeEnum.PrimitiveArray:
  124.                             byte inByte = dataReader.ReadByte();
  125.                             binaryHeaderEnum = (BinaryHeaderEnum)inByte;
  126.                             //Console.WriteLine("Beginning of loop "+((Enum)binaryHeaderEnum).ToString());
  127.                             switch (binaryHeaderEnum) {
  128.                                 case BinaryHeaderEnum.Assembly:
  129.                                 case BinaryHeaderEnum.CrossAppDomainAssembly:
  130.                                     ReadAssembly(binaryHeaderEnum);
  131.                                     break;
  132.                                 case BinaryHeaderEnum.Object:
  133.                                     ReadObject();
  134.                                     break;
  135.                                 case BinaryHeaderEnum.CrossAppDomainMap:
  136.                                     ReadCrossAppDomainMap();
  137.                                     break;
  138.                                 case BinaryHeaderEnum.ObjectWithMap:
  139.                                 case BinaryHeaderEnum.ObjectWithMapAssemId:
  140.                                     ReadObjectWithMap(binaryHeaderEnum);
  141.                                     break;
  142.                                 case BinaryHeaderEnum.ObjectWithMapTyped:
  143.                                 case BinaryHeaderEnum.ObjectWithMapTypedAssemId:
  144.                                     ReadObjectWithMapTyped(binaryHeaderEnum);
  145.                                     break;
  146.                                 case BinaryHeaderEnum.MethodCall:
  147.                                 case BinaryHeaderEnum.MethodReturn:
  148.                                     ReadMethodObject(binaryHeaderEnum);
  149.                                     break;
  150.                                 case BinaryHeaderEnum.ObjectString:
  151.                                 case BinaryHeaderEnum.CrossAppDomainString:
  152.                                     ReadObjectString(binaryHeaderEnum);
  153.                                     break;
  154.                                 case BinaryHeaderEnum.Array:
  155.                                 case BinaryHeaderEnum.ArraySinglePrimitive:
  156.                                 case BinaryHeaderEnum.ArraySingleObject:
  157.                                 case BinaryHeaderEnum.ArraySingleString:
  158.                                     ReadArray(binaryHeaderEnum);
  159.                                     break;
  160.                                 case BinaryHeaderEnum.MemberPrimitiveTyped:
  161.                                     ReadMemberPrimitiveTyped();
  162.                                     break;
  163.                                 case BinaryHeaderEnum.MemberReference:
  164.                                     ReadMemberReference();
  165.                                     break;
  166.                                 case BinaryHeaderEnum.ObjectNull:
  167.                                 case BinaryHeaderEnum.ObjectNullMultiple256:
  168.                                 case BinaryHeaderEnum.ObjectNullMultiple:
  169.                                     ReadObjectNull(binaryHeaderEnum);
  170.                                     break;
  171.                                 case BinaryHeaderEnum.MessageEnd:
  172.                                     isLoop = false;
  173.                                     ReadMessageEnd();
  174.                                     ReadEnd();
  175.                                     break;
  176.                                 default:
  177.                                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_BinaryHeader"), inByte));
  178.                                     break;
  179.                             }
  180.                             break;
  181.                         case BinaryTypeEnum.Primitive:
  182.                             ReadMemberPrimitiveUnTyped();
  183.                             break;
  184.                         default:
  185.                             throw new SerializationException(Environment.GetResourceString("Serialization_TypeExpected"));
  186.                             break;
  187.                        
  188.                     }
  189.                    
  190.                     // If an assembly is encountered, don't advance
  191.                     // object Progress,
  192.                     if (binaryHeaderEnum != BinaryHeaderEnum.Assembly) {
  193.                         // End of parse loop.
  194.                         bool isData = false;
  195.                         // Set up loop for next iteration.
  196.                         // If this is an object, and the end of object has been reached, then parse object end.
  197.                         while (!isData) {
  198.                             ObjectProgress op = (ObjectProgress)stack.Peek();
  199.                             if (op == null) {
  200.                                 // No more object on stack, then the next record is a top level object
  201.                                 SerTrace.Log(this, "Run loop op null, top level object");
  202.                                 expectedType = BinaryTypeEnum.ObjectUrt;
  203.                                 expectedTypeInformation = null;
  204.                                 isData = true;
  205.                             }
  206.                             else {
  207.                                 SerTrace.Log(this, "Run loop op not null, continue object");
  208.                                 // Find out what record is expected next
  209.                                 isData = op.GetNext(out op.expectedType, out op.expectedTypeInformation);
  210.                                 expectedType = op.expectedType;
  211.                                 expectedTypeInformation = op.expectedTypeInformation;
  212.                                 SerTrace.Log(this, "Run loop opName ", op.name, ", expectedType ", ((Enum)expectedType).ToString(), " expectedTypeInformation, ", expectedTypeInformation);
  213.                                
  214.                                 SerTrace.Log(this, "Run ", isData);
  215.                                 if (!isData) {
  216.                                     // No record is expected next, this is the end of an object or array
  217.                                     SerTrace.Log(this, "Run End of Object ");
  218.                                     stack.Dump();
  219.                                    
  220.                                     prs.Init();
  221.                                     if (op.memberValueEnum == InternalMemberValueE.Nested) {
  222.                                         // Nested object
  223.                                         prs.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
  224.                                         prs.PRmemberTypeEnum = op.memberTypeEnum;
  225.                                         prs.PRmemberValueEnum = op.memberValueEnum;
  226.                                         objectReader.Parse(prs);
  227.                                     }
  228.                                     else {
  229.                                         // Top level object
  230.                                         prs.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
  231.                                         prs.PRmemberTypeEnum = op.memberTypeEnum;
  232.                                         prs.PRmemberValueEnum = op.memberValueEnum;
  233.                                         objectReader.Parse(prs);
  234.                                     }
  235.                                     stack.Pop();
  236.                                     PutOp(op);
  237.                                 }
  238.                             }
  239.                         }
  240.                     }
  241.                 }
  242.             }
  243.             catch (EndOfStreamException) {
  244.                
  245.                 // EOF should never be thrown since there is a MessageEnd record to stop parsing
  246.                 BCLDebug.Trace("BINARY", "\n*****EOF*************************\n");
  247.                 throw new SerializationException(Environment.GetResourceString("Serialization_StreamEnd"));
  248.             }
  249.         }
  250.        
  251.        
  252.         internal void ReadBegin()
  253.         {
  254.             BCLDebug.Trace("BINARY", "\n%%%%%BinaryReaderBegin%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
  255.         }
  256.        
  257.         internal void ReadEnd()
  258.         {
  259.             BCLDebug.Trace("BINARY", "\n%%%%%BinaryReaderEnd%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
  260.         }
  261.        
  262. /*
  263. * Primitive Reads from Stream
  264. * @internalonly
  265. */       
  266.        
  267.         internal bool ReadBoolean()
  268.         {
  269.             return dataReader.ReadBoolean();
  270.         }
  271.        
  272.         internal byte ReadByte()
  273.         {
  274.             return dataReader.ReadByte();
  275.         }
  276.        
  277.         internal byte[] ReadBytes(int length)
  278.         {
  279.             return dataReader.ReadBytes(length);
  280.         }
  281.        
  282.         // Note: this method does a blocking read!
  283.         internal void ReadBytes(byte[] byteA, int offset, int size)
  284.         {
  285.             while (size > 0) {
  286.                 int n = dataReader.Read(byteA, offset, size);
  287.                 if (n == 0)
  288.                     __Error.EndOfFile();
  289.                 offset += n;
  290.                 size -= n;
  291.             }
  292.         }
  293.        
  294.         internal char ReadChar()
  295.         {
  296.             return dataReader.ReadChar();
  297.         }
  298.        
  299.         internal char[] ReadChars(int length)
  300.         {
  301.             return dataReader.ReadChars(length);
  302.         }
  303.        
  304.         internal decimal ReadDecimal()
  305.         {
  306.             return Decimal.Parse(dataReader.ReadString(), CultureInfo.InvariantCulture);
  307.         }
  308.        
  309.         internal float ReadSingle()
  310.         {
  311.             return dataReader.ReadSingle();
  312.         }
  313.        
  314.         internal double ReadDouble()
  315.         {
  316.             return dataReader.ReadDouble();
  317.         }
  318.        
  319.         internal Int16 ReadInt16()
  320.         {
  321.             return dataReader.ReadInt16();
  322.         }
  323.        
  324.         internal Int32 ReadInt32()
  325.         {
  326.             return dataReader.ReadInt32();
  327.         }
  328.        
  329.         internal Int64 ReadInt64()
  330.         {
  331.             return dataReader.ReadInt64();
  332.         }
  333.        
  334.         internal sbyte ReadSByte()
  335.         {
  336.             return (sbyte)ReadByte();
  337.         }
  338.        
  339.         internal string ReadString()
  340.         {
  341.             return dataReader.ReadString();
  342.         }
  343.        
  344.         internal TimeSpan ReadTimeSpan()
  345.         {
  346.             return new TimeSpan(ReadInt64());
  347.         }
  348.        
  349.         internal DateTime ReadDateTime()
  350.         {
  351.             return DateTime.FromBinaryRaw(ReadInt64());
  352.         }
  353.        
  354.         internal UInt16 ReadUInt16()
  355.         {
  356.             return dataReader.ReadUInt16();
  357.         }
  358.        
  359.         internal UInt32 ReadUInt32()
  360.         {
  361.             return dataReader.ReadUInt32();
  362.         }
  363.        
  364.         internal UInt64 ReadUInt64()
  365.         {
  366.             return dataReader.ReadUInt64();
  367.         }
  368.        
  369.         // Binary Stream Record Reads
  370.         internal void ReadSerializationHeaderRecord()
  371.         {
  372.             SerTrace.Log(this, "ReadSerializationHeaderRecord");
  373.             SerializationHeaderRecord record = new SerializationHeaderRecord();
  374.             record.Read(this);
  375.             record.Dump();
  376.             this.topId = (record.topId > 0 ? objectReader.GetId(record.topId) : record.topId);
  377.             this.headerId = (record.headerId > 0 ? objectReader.GetId(record.headerId) : record.headerId);
  378.         }
  379.        
  380.         internal void ReadAssembly(BinaryHeaderEnum binaryHeaderEnum)
  381.         {
  382.             SerTrace.Log(this, "ReadAssembly");
  383.             BinaryAssembly record = new BinaryAssembly();
  384.             if (binaryHeaderEnum == BinaryHeaderEnum.CrossAppDomainAssembly) {
  385.                 BinaryCrossAppDomainAssembly crossAppDomainAssembly = new BinaryCrossAppDomainAssembly();
  386.                 crossAppDomainAssembly.Read(this);
  387.                 crossAppDomainAssembly.Dump();
  388.                 record.assemId = crossAppDomainAssembly.assemId;
  389.                 record.assemblyString = objectReader.CrossAppDomainArray(crossAppDomainAssembly.assemblyIndex) as string;
  390.                 if (record.assemblyString == null)
  391.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_CrossAppDomainError"), "String", crossAppDomainAssembly.assemblyIndex));
  392.                
  393.             }
  394.             else {
  395.                 record.Read(this);
  396.                 record.Dump();
  397.             }
  398.            
  399.             AssemIdToAssemblyTable[record.assemId] = new BinaryAssemblyInfo(record.assemblyString);
  400.         }
  401.        
  402.         internal void ReadMethodObject(BinaryHeaderEnum binaryHeaderEnum)
  403.         {
  404.             SerTrace.Log(this, "ReadMethodObject");
  405.             if (binaryHeaderEnum == BinaryHeaderEnum.MethodCall) {
  406.                 BinaryMethodCall record = new BinaryMethodCall();
  407.                 record.Read(this);
  408.                 record.Dump();
  409.                 objectReader.SetMethodCall(record);
  410.             }
  411.             else {
  412.                 BinaryMethodReturn record = new BinaryMethodReturn();
  413.                 record.Read(this);
  414.                 record.Dump();
  415.                 objectReader.SetMethodReturn(record);
  416.             }
  417.         }
  418.        
  419.        
  420.         private BinaryObject binaryObject;
  421.        
  422.         private void ReadObject()
  423.         {
  424.             SerTrace.Log(this, "ReadObject");
  425.            
  426.             if (binaryObject == null)
  427.                 binaryObject = new BinaryObject();
  428.             binaryObject.Read(this);
  429.             binaryObject.Dump();
  430.            
  431.             ObjectMap objectMap = (ObjectMap)ObjectMapIdTable[binaryObject.mapId];
  432.             if (objectMap == null)
  433.                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Map"), binaryObject.mapId));
  434.            
  435.             ObjectProgress op = GetOp();
  436.             ParseRecord pr = op.pr;
  437.             stack.Push(op);
  438.            
  439.             op.objectTypeEnum = InternalObjectTypeE.Object;
  440.             op.binaryTypeEnumA = objectMap.binaryTypeEnumA;
  441.             op.memberNames = objectMap.memberNames;
  442.             op.memberTypes = objectMap.memberTypes;
  443.             op.typeInformationA = objectMap.typeInformationA;
  444.             op.memberLength = op.binaryTypeEnumA.Length;
  445.             ObjectProgress objectOp = (ObjectProgress)stack.PeekPeek();
  446.             if ((objectOp == null) || (objectOp.isInitial)) {
  447.                 // Non-Nested Object
  448.                 SerTrace.Log(this, "ReadObject non-nested ");
  449.                 op.name = objectMap.objectName;
  450.                 pr.PRparseTypeEnum = InternalParseTypeE.Object;
  451.                 op.memberValueEnum = InternalMemberValueE.Empty;
  452.             }
  453.             else {
  454.                 // Nested Object
  455.                 SerTrace.Log(this, "ReadObject nested ");
  456.                 pr.PRparseTypeEnum = InternalParseTypeE.Member;
  457.                 pr.PRmemberValueEnum = InternalMemberValueE.Nested;
  458.                 op.memberValueEnum = InternalMemberValueE.Nested;
  459.                
  460.                 switch (objectOp.objectTypeEnum) {
  461.                     case InternalObjectTypeE.Object:
  462.                         pr.PRname = objectOp.name;
  463.                         pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
  464.                         op.memberTypeEnum = InternalMemberTypeE.Field;
  465.                         break;
  466.                     case InternalObjectTypeE.Array:
  467.                         pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
  468.                         op.memberTypeEnum = InternalMemberTypeE.Item;
  469.                         break;
  470.                     default:
  471.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Map"), ((Enum)objectOp.objectTypeEnum).ToString()));
  472.                         break;
  473.                 }
  474.             }
  475.            
  476.            
  477.             pr.PRobjectId = objectReader.GetId((long)binaryObject.objectId);
  478.             SerTrace.Log(this, "ReadObject binaryObject.objectId ", pr.PRobjectId);
  479.             pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData);
  480.            
  481.             if (pr.PRobjectId == topId)
  482.                 pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
  483.            
  484.             pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
  485.             pr.PRkeyDt = objectMap.objectName;
  486.             pr.PRdtType = objectMap.objectType;
  487.             pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
  488.             objectReader.Parse(pr);
  489.         }
  490.        
  491.         internal void ReadCrossAppDomainMap()
  492.         {
  493.             SerTrace.Log(this, "ReadObjectWithCrossAppDomainMap");
  494.             BinaryCrossAppDomainMap record = new BinaryCrossAppDomainMap();
  495.             record.Read(this);
  496.             record.Dump();
  497.             object mapObject = objectReader.CrossAppDomainArray(record.crossAppDomainArrayIndex);
  498.             BinaryObjectWithMap binaryObjectWithMap = mapObject as BinaryObjectWithMap;
  499.             if (binaryObjectWithMap != null) {
  500.                 binaryObjectWithMap.Dump();
  501.                 ReadObjectWithMap(binaryObjectWithMap);
  502.             }
  503.             else {
  504.                 BinaryObjectWithMapTyped binaryObjectWithMapTyped = mapObject as BinaryObjectWithMapTyped;
  505.                 if (binaryObjectWithMapTyped != null) {
  506.                     #if _DEBUG
  507.                     binaryObjectWithMapTyped.Dump();
  508.                     #endif
  509.                     ReadObjectWithMapTyped(binaryObjectWithMapTyped);
  510.                 }
  511.                 else
  512.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_CrossAppDomainError"), "BinaryObjectMap", mapObject));
  513.             }
  514.         }
  515.        
  516.        
  517.         private BinaryObjectWithMap bowm;
  518.        
  519.         internal void ReadObjectWithMap(BinaryHeaderEnum binaryHeaderEnum)
  520.         {
  521.             SerTrace.Log(this, "ReadObjectWithMap");
  522.             if (bowm == null)
  523.                 bowm = new BinaryObjectWithMap(binaryHeaderEnum);
  524.             else
  525.                 bowm.binaryHeaderEnum = binaryHeaderEnum;
  526.             bowm.Read(this);
  527.             bowm.Dump();
  528.             ReadObjectWithMap(bowm);
  529.         }
  530.        
  531.         private void ReadObjectWithMap(BinaryObjectWithMap record)
  532.         {
  533.             BinaryAssemblyInfo assemblyInfo = null;
  534.             ObjectProgress op = GetOp();
  535.             ParseRecord pr = op.pr;
  536.             stack.Push(op);
  537.            
  538.            
  539.             if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapAssemId) {
  540.                 if (record.assemId < 1)
  541.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Assembly"), record.name));
  542.                
  543.                 assemblyInfo = ((BinaryAssemblyInfo)AssemIdToAssemblyTable[record.assemId]);
  544.                
  545.                 if (assemblyInfo == null)
  546.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Assembly"), record.assemId + " " + record.name));
  547.                 SerTrace.Log(this, "ReadObjectWithMap lookup assemIdToAssembly assemId ", record.assemId, " assembly ", assemblyInfo.assemblyString);
  548.             }
  549.             else if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMap) {
  550.                
  551.                 assemblyInfo = SystemAssemblyInfo;
  552.                 //Urt assembly
  553.             }
  554.            
  555.             Type objectType = objectReader.GetType(assemblyInfo, record.name);
  556.            
  557.             ObjectMap objectMap = ObjectMap.Create(record.name, objectType, record.memberNames, objectReader, record.objectId, assemblyInfo);
  558.             ObjectMapIdTable[record.objectId] = objectMap;
  559.            
  560.             op.objectTypeEnum = InternalObjectTypeE.Object;
  561.             op.binaryTypeEnumA = objectMap.binaryTypeEnumA;
  562.             op.typeInformationA = objectMap.typeInformationA;
  563.             op.memberLength = op.binaryTypeEnumA.Length;
  564.             op.memberNames = objectMap.memberNames;
  565.             op.memberTypes = objectMap.memberTypes;
  566.            
  567.             ObjectProgress objectOp = (ObjectProgress)stack.PeekPeek();
  568.            
  569.             if ((objectOp == null) || (objectOp.isInitial)) {
  570.                 // Non-Nested Object
  571.                 op.name = record.name;
  572.                 pr.PRparseTypeEnum = InternalParseTypeE.Object;
  573.                 op.memberValueEnum = InternalMemberValueE.Empty;
  574.                
  575.             }
  576.             else {
  577.                 // Nested Object
  578.                 pr.PRparseTypeEnum = InternalParseTypeE.Member;
  579.                 pr.PRmemberValueEnum = InternalMemberValueE.Nested;
  580.                 op.memberValueEnum = InternalMemberValueE.Nested;
  581.                
  582.                 switch (objectOp.objectTypeEnum) {
  583.                     case InternalObjectTypeE.Object:
  584.                         pr.PRname = objectOp.name;
  585.                         pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
  586.                         op.memberTypeEnum = InternalMemberTypeE.Field;
  587.                         break;
  588.                     case InternalObjectTypeE.Array:
  589.                         pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
  590.                         op.memberTypeEnum = InternalMemberTypeE.Field;
  591.                         break;
  592.                     default:
  593.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_ObjectTypeEnum"), ((Enum)objectOp.objectTypeEnum).ToString()));
  594.                         break;
  595.                 }
  596.                
  597.             }
  598.             pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
  599.             pr.PRobjectId = objectReader.GetId((long)record.objectId);
  600.             pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData);
  601.            
  602.             if (pr.PRobjectId == topId)
  603.                 pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
  604.            
  605.             pr.PRkeyDt = record.name;
  606.             pr.PRdtType = objectMap.objectType;
  607.             pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
  608.             objectReader.Parse(pr);
  609.         }
  610.        
  611.         private BinaryObjectWithMapTyped bowmt;
  612.        
  613.         internal void ReadObjectWithMapTyped(BinaryHeaderEnum binaryHeaderEnum)
  614.         {
  615.             SerTrace.Log(this, "ReadObjectWithMapTyped");
  616.             if (bowmt == null)
  617.                 bowmt = new BinaryObjectWithMapTyped(binaryHeaderEnum);
  618.             else
  619.                 bowmt.binaryHeaderEnum = binaryHeaderEnum;
  620.             bowmt.Read(this);
  621.             #if _DEBUG
  622.             bowmt.Dump();
  623.             #endif
  624.             ReadObjectWithMapTyped(bowmt);
  625.         }
  626.        
  627.         private void ReadObjectWithMapTyped(BinaryObjectWithMapTyped record)
  628.         {
  629.             BinaryAssemblyInfo assemblyInfo = null;
  630.             ObjectProgress op = GetOp();
  631.             ParseRecord pr = op.pr;
  632.             stack.Push(op);
  633.            
  634.             if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTypedAssemId) {
  635.                 if (record.assemId < 1)
  636.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_AssemblyId"), record.name));
  637.                
  638.                 assemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[record.assemId];
  639.                 if (assemblyInfo == null)
  640.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_AssemblyId"), record.assemId + " " + record.name));
  641.                
  642.                 SerTrace.Log(this, "ReadObjectWithMapTyped lookup assemIdToAssembly assemId ", record.assemId, " assembly ", assemblyInfo.assemblyString);
  643.             }
  644.             else if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTyped) {
  645.                 assemblyInfo = SystemAssemblyInfo;
  646.                 // Urt assembly
  647.             }
  648.            
  649.             ObjectMap objectMap = ObjectMap.Create(record.name, record.memberNames, record.binaryTypeEnumA, record.typeInformationA, record.memberAssemIds, objectReader, record.objectId, assemblyInfo, AssemIdToAssemblyTable);
  650.             ObjectMapIdTable[record.objectId] = objectMap;
  651.             op.objectTypeEnum = InternalObjectTypeE.Object;
  652.             op.binaryTypeEnumA = objectMap.binaryTypeEnumA;
  653.             op.typeInformationA = objectMap.typeInformationA;
  654.             op.memberLength = op.binaryTypeEnumA.Length;
  655.             op.memberNames = objectMap.memberNames;
  656.             op.memberTypes = objectMap.memberTypes;
  657.            
  658.             ObjectProgress objectOp = (ObjectProgress)stack.PeekPeek();
  659.            
  660.             if ((objectOp == null) || (objectOp.isInitial)) {
  661.                 // Non-Nested Object
  662.                 op.name = record.name;
  663.                 pr.PRparseTypeEnum = InternalParseTypeE.Object;
  664.                 op.memberValueEnum = InternalMemberValueE.Empty;
  665.             }
  666.             else {
  667.                 // Nested Object
  668.                 pr.PRparseTypeEnum = InternalParseTypeE.Member;
  669.                 pr.PRmemberValueEnum = InternalMemberValueE.Nested;
  670.                 op.memberValueEnum = InternalMemberValueE.Nested;
  671.                
  672.                 switch (objectOp.objectTypeEnum) {
  673.                     case InternalObjectTypeE.Object:
  674.                         pr.PRname = objectOp.name;
  675.                         pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
  676.                         op.memberTypeEnum = InternalMemberTypeE.Field;
  677.                         break;
  678.                     case InternalObjectTypeE.Array:
  679.                         pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
  680.                         op.memberTypeEnum = InternalMemberTypeE.Item;
  681.                         break;
  682.                     default:
  683.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_ObjectTypeEnum"), ((Enum)objectOp.objectTypeEnum).ToString()));
  684.                         break;
  685.                 }
  686.                
  687.             }
  688.            
  689.             pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
  690.             pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData);
  691.             pr.PRobjectId = objectReader.GetId((long)record.objectId);
  692.             if (pr.PRobjectId == topId)
  693.                 pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
  694.             pr.PRkeyDt = record.name;
  695.             pr.PRdtType = objectMap.objectType;
  696.             pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
  697.             objectReader.Parse(pr);
  698.         }
  699.        
  700.         internal BinaryObjectString objectString;
  701.         internal BinaryCrossAppDomainString crossAppDomainString;
  702.        
  703.         private void ReadObjectString(BinaryHeaderEnum binaryHeaderEnum)
  704.         {
  705.             SerTrace.Log(this, "ReadObjectString");
  706.            
  707.             if (objectString == null)
  708.                 objectString = new BinaryObjectString();
  709.            
  710.             if (binaryHeaderEnum == BinaryHeaderEnum.ObjectString) {
  711.                 objectString.Read(this);
  712.                 objectString.Dump();
  713.             }
  714.             else {
  715.                 if (crossAppDomainString == null)
  716.                     crossAppDomainString = new BinaryCrossAppDomainString();
  717.                 crossAppDomainString.Read(this);
  718.                 crossAppDomainString.Dump();
  719.                 objectString.value = objectReader.CrossAppDomainArray(crossAppDomainString.value) as string;
  720.                 if (objectString.value == null)
  721.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_CrossAppDomainError"), "String", crossAppDomainString.value));
  722.                
  723.                 objectString.objectId = crossAppDomainString.objectId;
  724.             }
  725.            
  726.             prs.Init();
  727.             prs.PRparseTypeEnum = InternalParseTypeE.Object;
  728.             prs.PRobjectId = objectReader.GetId(objectString.objectId);
  729.            
  730.             if (prs.PRobjectId == topId)
  731.                 prs.PRobjectPositionEnum = InternalObjectPositionE.Top;
  732.            
  733.             prs.PRobjectTypeEnum = InternalObjectTypeE.Object;
  734.            
  735.             ObjectProgress objectOp = (ObjectProgress)stack.Peek();
  736.            
  737.             prs.PRvalue = objectString.value;
  738.             prs.PRkeyDt = "System.String";
  739.             prs.PRdtType = Converter.typeofString;
  740.             prs.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
  741.             prs.PRvarValue = objectString.value;
  742.             //Need to set it because ObjectReader is picking up value from variant, not pr.PRvalue
  743.             if (objectOp == null) {
  744.                 // Top level String
  745.                 SerTrace.Log(this, "ReadObjectString, Non-Nested");
  746.                 prs.PRparseTypeEnum = InternalParseTypeE.Object;
  747.                 prs.PRname = "System.String";
  748.             }
  749.             else {
  750.                 // Nested in an Object
  751.                
  752.                 SerTrace.Log(this, "ReadObjectString, Nested");
  753.                 prs.PRparseTypeEnum = InternalParseTypeE.Member;
  754.                 prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
  755.                
  756.                 switch (objectOp.objectTypeEnum) {
  757.                     case InternalObjectTypeE.Object:
  758.                         prs.PRname = objectOp.name;
  759.                         prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
  760.                         break;
  761.                     case InternalObjectTypeE.Array:
  762.                         prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
  763.                         break;
  764.                     default:
  765.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_ObjectTypeEnum"), ((Enum)objectOp.objectTypeEnum).ToString()));
  766.                         break;
  767.                 }
  768.                
  769.             }
  770.            
  771.             objectReader.Parse(prs);
  772.         }
  773.        
  774.        
  775.        
  776.         internal MemberPrimitiveTyped memberPrimitiveTyped;
  777.        
  778.         private void ReadMemberPrimitiveTyped()
  779.         {
  780.             SerTrace.Log(this, "ReadObjectPrimitive");
  781.            
  782.             if (memberPrimitiveTyped == null)
  783.                 memberPrimitiveTyped = new MemberPrimitiveTyped();
  784.            
  785.             memberPrimitiveTyped.Read(this);
  786.             memberPrimitiveTyped.Dump();
  787.            
  788.             prs.PRobjectTypeEnum = InternalObjectTypeE.Object;
  789.             //Get rid of
  790.             ObjectProgress objectOp = (ObjectProgress)stack.Peek();
  791.            
  792.             prs.Init();
  793.             prs.PRvarValue = memberPrimitiveTyped.value;
  794.             prs.PRkeyDt = Converter.ToComType(memberPrimitiveTyped.primitiveTypeEnum);
  795.             prs.PRdtType = Converter.ToType(memberPrimitiveTyped.primitiveTypeEnum);
  796.             prs.PRdtTypeCode = memberPrimitiveTyped.primitiveTypeEnum;
  797.            
  798.             if (objectOp == null) {
  799.                 // Top level boxed primitive
  800.                 SerTrace.Log(this, "ReadObjectPrimitive, Non-Nested");
  801.                 prs.PRparseTypeEnum = InternalParseTypeE.Object;
  802.                 prs.PRname = "System.Variant";
  803.             }
  804.             else {
  805.                 // Nested in an Object
  806.                 SerTrace.Log(this, "ReadObjectPrimitive, Nested");
  807.                
  808.                 prs.PRparseTypeEnum = InternalParseTypeE.Member;
  809.                 prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
  810.                
  811.                 switch (objectOp.objectTypeEnum) {
  812.                     case InternalObjectTypeE.Object:
  813.                         prs.PRname = objectOp.name;
  814.                         prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
  815.                         break;
  816.                     case InternalObjectTypeE.Array:
  817.                         prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
  818.                         break;
  819.                     default:
  820.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_ObjectTypeEnum"), ((Enum)objectOp.objectTypeEnum).ToString()));
  821.                         break;
  822.                 }
  823.             }
  824.            
  825.             objectReader.Parse(prs);
  826.         }
  827.        
  828.        
  829.         private void ReadArray(BinaryHeaderEnum binaryHeaderEnum)
  830.         {
  831.             BinaryAssemblyInfo assemblyInfo = null;
  832.             SerTrace.Log(this, "ReadArray ");
  833.             BinaryArray record = new BinaryArray(binaryHeaderEnum);
  834.             record.Read(this);
  835.             #if _DEBUG
  836.             record.Dump();
  837.            
  838.             SerTrace.Log(this, "Read 1 ", ((Enum)binaryHeaderEnum).ToString());
  839.             #endif
  840.             if (record.binaryTypeEnum == BinaryTypeEnum.ObjectUser) {
  841.                 if (record.assemId < 1)
  842.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_AssemblyId"), record.typeInformation));
  843.                
  844.                 assemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[record.assemId];
  845.                 SerTrace.Log(this, "ReadArray lookup assemIdToAssembly assemId ", record.assemId, " assembly ", assemblyInfo.assemblyString);
  846.             }
  847.             else
  848.                 assemblyInfo = SystemAssemblyInfo;
  849.             //Urt assembly
  850.             ObjectProgress op = GetOp();
  851.             ParseRecord pr = op.pr;
  852.            
  853.             op.objectTypeEnum = InternalObjectTypeE.Array;
  854.             op.binaryTypeEnum = record.binaryTypeEnum;
  855.             op.typeInformation = record.typeInformation;
  856.            
  857.             ObjectProgress objectOp = (ObjectProgress)stack.PeekPeek();
  858.             if ((objectOp == null) || (record.objectId > 0)) {
  859.                 // Non-Nested Object
  860.                 op.name = "System.Array";
  861.                 pr.PRparseTypeEnum = InternalParseTypeE.Object;
  862.                 op.memberValueEnum = InternalMemberValueE.Empty;
  863.             }
  864.             else {
  865.                 // Nested Object
  866.                 pr.PRparseTypeEnum = InternalParseTypeE.Member;
  867.                 pr.PRmemberValueEnum = InternalMemberValueE.Nested;
  868.                 op.memberValueEnum = InternalMemberValueE.Nested;
  869.                
  870.                 switch (objectOp.objectTypeEnum) {
  871.                     case InternalObjectTypeE.Object:
  872.                         pr.PRname = objectOp.name;
  873.                         pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
  874.                         op.memberTypeEnum = InternalMemberTypeE.Field;
  875.                         pr.PRkeyDt = objectOp.name;
  876.                         pr.PRdtType = objectOp.dtType;
  877.                         break;
  878.                     case InternalObjectTypeE.Array:
  879.                         pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
  880.                         op.memberTypeEnum = InternalMemberTypeE.Item;
  881.                         break;
  882.                     default:
  883.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_ObjectTypeEnum"), ((Enum)objectOp.objectTypeEnum).ToString()));
  884.                         break;
  885.                 }
  886.             }
  887.            
  888.            
  889.             pr.PRobjectId = objectReader.GetId((long)record.objectId);
  890.             if (pr.PRobjectId == topId)
  891.                 pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
  892.             else if ((headerId > 0) && (pr.PRobjectId == headerId))
  893.                 pr.PRobjectPositionEnum = InternalObjectPositionE.Headers;
  894.             else
  895.                 // Headers are an array of header objects
  896.                 pr.PRobjectPositionEnum = InternalObjectPositionE.Child;
  897.            
  898.             pr.PRobjectTypeEnum = InternalObjectTypeE.Array;
  899.            
  900.             BinaryConverter.TypeFromInfo(record.binaryTypeEnum, record.typeInformation, objectReader, assemblyInfo, out pr.PRarrayElementTypeCode, out pr.PRarrayElementTypeString, out pr.PRarrayElementType, out pr.PRisArrayVariant);
  901.            
  902.             pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
  903.            
  904.            
  905.             pr.PRrank = record.rank;
  906.             pr.PRlengthA = record.lengthA;
  907.             pr.PRlowerBoundA = record.lowerBoundA;
  908.             bool isPrimitiveArray = false;
  909.            
  910.             switch (record.binaryArrayTypeEnum) {
  911.                 case BinaryArrayTypeEnum.Single:
  912.                 case BinaryArrayTypeEnum.SingleOffset:
  913.                     op.numItems = record.lengthA[0];
  914.                     pr.PRarrayTypeEnum = InternalArrayTypeE.Single;
  915.                     if (Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode) && (record.lowerBoundA[0] == 0)) {
  916.                         isPrimitiveArray = true;
  917.                         ReadArrayAsBytes(pr);
  918.                     }
  919.                     break;
  920.                 case BinaryArrayTypeEnum.Jagged:
  921.                 case BinaryArrayTypeEnum.JaggedOffset:
  922.                     op.numItems = record.lengthA[0];
  923.                     pr.PRarrayTypeEnum = InternalArrayTypeE.Jagged;
  924.                     break;
  925.                 case BinaryArrayTypeEnum.Rectangular:
  926.                 case BinaryArrayTypeEnum.RectangularOffset:
  927.                     int arrayLength = 1;
  928.                     for (int i = 0; i < record.rank; i++)
  929.                         arrayLength = arrayLength * record.lengthA[i];
  930.                     op.numItems = arrayLength;
  931.                     pr.PRarrayTypeEnum = InternalArrayTypeE.Rectangular;
  932.                     break;
  933.                 default:
  934.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_ArrayType"), ((Enum)record.binaryArrayTypeEnum).ToString()));
  935.                     break;
  936.             }
  937.            
  938.             if (!isPrimitiveArray)
  939.                 stack.Push(op);
  940.             else {
  941.                 PutOp(op);
  942.             }
  943.            
  944.             SerTrace.Log(this, "ReadArray ", ((Enum)record.binaryArrayTypeEnum).ToString(), " length ", op.numItems);
  945.             objectReader.Parse(pr);
  946.            
  947.             if (isPrimitiveArray) {
  948.                 pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
  949.                 objectReader.Parse(pr);
  950.             }
  951.         }
  952.        
  953.         private byte[] byteBuffer;
  954.         private const int chunkSize = 4096;
  955.        
  956.         private void ReadArrayAsBytes(ParseRecord pr)
  957.         {
  958.             if (pr.PRarrayElementTypeCode == InternalPrimitiveTypeE.Byte)
  959.                 pr.PRnewObj = ReadBytes(pr.PRlengthA[0]);
  960.             else if (pr.PRarrayElementTypeCode == InternalPrimitiveTypeE.Char)
  961.                 pr.PRnewObj = ReadChars(pr.PRlengthA[0]);
  962.             else {
  963.                 int typeLength = Converter.TypeLength(pr.PRarrayElementTypeCode);
  964.                
  965.                 pr.PRnewObj = Converter.CreatePrimitiveArray(pr.PRarrayElementTypeCode, pr.PRlengthA[0]);
  966.                
  967.                 //pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA[0]);
  968.                 BCLDebug.Assert((pr.PRnewObj != null), "[BinaryParser expected a Primitive Array]");
  969.                
  970.                 Array array = (Array)pr.PRnewObj;
  971.                 int arrayOffset = 0;
  972.                 if (byteBuffer == null)
  973.                     byteBuffer = new byte[chunkSize];
  974.                
  975.                 while (arrayOffset < array.Length) {
  976.                     int numArrayItems = Math.Min(chunkSize / typeLength, array.Length - arrayOffset);
  977.                     int bufferUsed = numArrayItems * typeLength;
  978.                     ReadBytes(byteBuffer, 0, bufferUsed);
  979.                     #if BIGENDIAN
  980.                     // we know that we are reading a primitive type, so just do a simple swap
  981.                     for (int i = 0; i < bufferUsed; i += typeLength) {
  982.                         for (int j = 0; j < typeLength / 2; j++) {
  983.                             byte tmp = byteBuffer[i + j];
  984.                             byteBuffer[i + j] = byteBuffer[i + typeLength - 1 - j];
  985.                             byteBuffer[i + typeLength - 1 - j] = tmp;
  986.                         }
  987.                     }
  988.                     #endif
  989.                     Buffer.InternalBlockCopy(byteBuffer, 0, array, arrayOffset * typeLength, bufferUsed);
  990.                     arrayOffset += numArrayItems;
  991.                 }
  992.             }
  993.         }
  994.        
  995.         internal MemberPrimitiveUnTyped memberPrimitiveUnTyped;
  996.        
  997.         private void ReadMemberPrimitiveUnTyped()
  998.         {
  999.             SerTrace.Log(this, "ReadMemberPrimitiveUnTyped ");
  1000.             ObjectProgress objectOp = (ObjectProgress)stack.Peek();
  1001.             if (memberPrimitiveUnTyped == null)
  1002.                 memberPrimitiveUnTyped = new MemberPrimitiveUnTyped();
  1003.             memberPrimitiveUnTyped.Set((InternalPrimitiveTypeE)expectedTypeInformation);
  1004.             memberPrimitiveUnTyped.Read(this);
  1005.             memberPrimitiveUnTyped.Dump();
  1006.            
  1007.             prs.Init();
  1008.             prs.PRvarValue = memberPrimitiveUnTyped.value;
  1009.            
  1010.             prs.PRdtTypeCode = (InternalPrimitiveTypeE)expectedTypeInformation;
  1011.             prs.PRdtType = Converter.ToType(prs.PRdtTypeCode);
  1012.             prs.PRparseTypeEnum = InternalParseTypeE.Member;
  1013.             prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
  1014.            
  1015.             if (objectOp.objectTypeEnum == InternalObjectTypeE.Object) {
  1016.                 prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
  1017.                 prs.PRname = objectOp.name;
  1018.             }
  1019.             else
  1020.                 prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
  1021.            
  1022.             objectReader.Parse(prs);
  1023.         }
  1024.        
  1025.        
  1026.         internal MemberReference memberReference;
  1027.        
  1028.         private void ReadMemberReference()
  1029.         {
  1030.             SerTrace.Log(this, "ReadMemberReference ");
  1031.            
  1032.             if (memberReference == null)
  1033.                 memberReference = new MemberReference();
  1034.             memberReference.Read(this);
  1035.             memberReference.Dump();
  1036.            
  1037.             ObjectProgress objectOp = (ObjectProgress)stack.Peek();
  1038.            
  1039.             prs.Init();
  1040.             prs.PRidRef = objectReader.GetId((long)memberReference.idRef);
  1041.             prs.PRparseTypeEnum = InternalParseTypeE.Member;
  1042.             prs.PRmemberValueEnum = InternalMemberValueE.Reference;
  1043.            
  1044.             if (objectOp.objectTypeEnum == InternalObjectTypeE.Object) {
  1045.                 prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
  1046.                 prs.PRname = objectOp.name;
  1047.                 prs.PRdtType = objectOp.dtType;
  1048.             }
  1049.             else
  1050.                 prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
  1051.            
  1052.            
  1053.             objectReader.Parse(prs);
  1054.         }
  1055.        
  1056.         internal ObjectNull objectNull;
  1057.        
  1058.         private void ReadObjectNull(BinaryHeaderEnum binaryHeaderEnum)
  1059.         {
  1060.             SerTrace.Log(this, "ReadObjectNull ");
  1061.            
  1062.             if (objectNull == null)
  1063.                 objectNull = new ObjectNull();
  1064.            
  1065.             objectNull.Read(this, binaryHeaderEnum);
  1066.             objectNull.Dump();
  1067.            
  1068.             ObjectProgress objectOp = (ObjectProgress)stack.Peek();
  1069.            
  1070.             prs.Init();
  1071.             prs.PRparseTypeEnum = InternalParseTypeE.Member;
  1072.             prs.PRmemberValueEnum = InternalMemberValueE.Null;
  1073.            
  1074.             if (objectOp.objectTypeEnum == InternalObjectTypeE.Object) {
  1075.                 prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
  1076.                 prs.PRname = objectOp.name;
  1077.                 prs.PRdtType = objectOp.dtType;
  1078.             }
  1079.             else {
  1080.                 prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
  1081.                 prs.PRnullCount = objectNull.nullCount;
  1082.                 //only one null position has been incremented by GetNext
  1083.                 //The position needs to be reset for the rest of the nulls
  1084.                 objectOp.ArrayCountIncrement(objectNull.nullCount - 1);
  1085.             }
  1086.             objectReader.Parse(prs);
  1087.         }
  1088.        
  1089.         static internal MessageEnd messageEnd;
  1090.        
  1091.         private void ReadMessageEnd()
  1092.         {
  1093.             SerTrace.Log(this, "ReadMessageEnd ");
  1094.            
  1095.             if (messageEnd == null)
  1096.                 messageEnd = new MessageEnd();
  1097.            
  1098.             messageEnd.Read(this);
  1099.            
  1100.             messageEnd.Dump();
  1101.            
  1102.             if (!stack.IsEmpty()) {
  1103.                 SerTrace.Log(this, "ReadMessageEnd Stack not empty ");
  1104.                 stack.Dump();
  1105.                 throw new SerializationException(Environment.GetResourceString("Serialization_StreamEnd"));
  1106.             }
  1107.         }
  1108.        
  1109.        
  1110.         // ReadValue from stream using InternalPrimitiveTypeE code
  1111.         internal object ReadValue(InternalPrimitiveTypeE code)
  1112.         {
  1113.             SerTrace.Log(this, "ReadValue ", ((Enum)code).ToString());
  1114.             object var = null;
  1115.            
  1116.             switch (code) {
  1117.                 case InternalPrimitiveTypeE.Boolean:
  1118.                     var = ReadBoolean();
  1119.                     break;
  1120.                 case InternalPrimitiveTypeE.Byte:
  1121.                     var = ReadByte();
  1122.                     break;
  1123.                 case InternalPrimitiveTypeE.Char:
  1124.                     var = ReadChar();
  1125.                     break;
  1126.                 case InternalPrimitiveTypeE.Double:
  1127.                     var = ReadDouble();
  1128.                     break;
  1129.                 case InternalPrimitiveTypeE.Int16:
  1130.                     var = ReadInt16();
  1131.                     break;
  1132.                 case InternalPrimitiveTypeE.Int32:
  1133.                     var = ReadInt32();
  1134.                     break;
  1135.                 case InternalPrimitiveTypeE.Int64:
  1136.                     var = ReadInt64();
  1137.                     break;
  1138.                 case InternalPrimitiveTypeE.SByte:
  1139.                     var = ReadSByte();
  1140.                     break;
  1141.                 case InternalPrimitiveTypeE.Single:
  1142.                     var = ReadSingle();
  1143.                     break;
  1144.                 case InternalPrimitiveTypeE.UInt16:
  1145.                     var = ReadUInt16();
  1146.                     break;
  1147.                 case InternalPrimitiveTypeE.UInt32:
  1148.                     var = ReadUInt32();
  1149.                     break;
  1150.                 case InternalPrimitiveTypeE.UInt64:
  1151.                     var = ReadUInt64();
  1152.                     break;
  1153.                 case InternalPrimitiveTypeE.Decimal:
  1154.                     var = ReadDecimal();
  1155.                     break;
  1156.                 case InternalPrimitiveTypeE.TimeSpan:
  1157.                     var = ReadTimeSpan();
  1158.                     break;
  1159.                 case InternalPrimitiveTypeE.DateTime:
  1160.                     var = ReadDateTime();
  1161.                     break;
  1162.                 default:
  1163.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_TypeCode"), ((Enum)code).ToString()));
  1164.                     break;
  1165.             }
  1166.             SerTrace.Log("ReadValue Exit ", var);
  1167.             return var;
  1168.         }
  1169.        
  1170.         private ObjectProgress GetOp()
  1171.         {
  1172.             ObjectProgress op = null;
  1173.            
  1174.             if (opPool != null && !opPool.IsEmpty()) {
  1175.                 op = (ObjectProgress)opPool.Pop();
  1176.                 op.Init();
  1177.             }
  1178.             else
  1179.                 op = new ObjectProgress();
  1180.            
  1181.             return op;
  1182.         }
  1183.        
  1184.         private void PutOp(ObjectProgress op)
  1185.         {
  1186.             if (opPool == null)
  1187.                 opPool = new SerStack("opPool");
  1188.             opPool.Push(op);
  1189.         }
  1190.        
  1191.     }
  1192. }

Developer Fusion