We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Runtime.Serialization.Formatters.Soap \ ITrace

SSCLI
  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: SoapCommonClasses
  18. // Purpose: utility classes
  19. //
  20. // Date: June 10, 1999
  21. //
  22. //============================================================
  24. namespace System.Runtime.Serialization.Formatters.Soap
  25. {
  26.     using System;
  27.     using System.Collections;
  28.     using System.Reflection;
  29.     using System.Text;
  30.     using System.Globalization;
  31.     using System.Runtime.Serialization.Formatters;
  32.     using System.Runtime.Remoting;
  33.     using System.Runtime.Remoting.Metadata;
  34.     using System.Runtime.Remoting.Messaging;
  35.     using System.Runtime.InteropServices;
  36.     using System.Runtime.Serialization;
  37.     using System.Resources;
  38.     using System.Diagnostics;
  39.    
  40.     // AttributeList class is used to transmit attributes from XMLObjectWriter to XMLWriter
  41.     internal sealed class AttributeList
  42.     {
  43.         private SerStack nameA = new SerStack("AttributeName");
  44.         private SerStack valueA = new SerStack("AttributeValue");
  45.        
  46.         internal int Count {
  47.             get { return nameA.Count(); }
  48.         }
  49.        
  50.         internal void Clear()
  51.         {
  52.             nameA.Clear();
  53.             valueA.Clear();
  54.         }
  55.        
  56.         internal void Put(string name, string value)
  57.         {
  58.             nameA.Push(name);
  59.             valueA.Push(value);
  60.         }
  61.        
  62.         internal void Get(int index, out string name, out string value)
  63.         {
  64.             name = (string)nameA.Next();
  65.             value = (string)valueA.Next();
  66.         }
  67.        
  68.         [Conditional("SER_LOGGING")]
  69.         internal void Dump()
  70.         {
  71.             nameA.Dump();
  72.             valueA.Dump();
  73.         }
  74.     }
  75.    
  76.     // Implements a stack used for parsing
  77.    
  78.     internal sealed class SerStack
  79.     {
  80.         //internal ArrayList stack = new ArrayList(10);
  81.         internal object[] objects = new object[10];
  82.         internal string stackId;
  83.         internal int top = -1;
  84.         internal int next = 0;
  85.        
  86.         internal SerStack(string stackId)
  87.         {
  88.             this.stackId = stackId;
  89.         }
  90.        
  91.         internal object GetItem(int index)
  92.         {
  93.             return objects[index];
  94.         }
  95.        
  96.         internal void Clear()
  97.         {
  98.             top = -1;
  99.             next = 0;
  100.         }
  101.        
  102.         // Push the object onto the stack
  103.         internal void Push(object obj)
  104.         {
  105.             InternalST.Soap(this, "Push ", stackId, " ", ((obj is ITrace) ? ((ITrace)obj).Trace() : ""));
  106.             if (top == (objects.Length - 1)) {
  107.                 IncreaseCapacity();
  108.             }
  109.             objects[++top] = obj;
  110.         }
  111.        
  112.         // Pop the object from the stack
  113.         internal object Pop()
  114.         {
  115.             if (top < 0)
  116.                 return null;
  117.            
  118.             object obj = objects[top];
  119.             objects[top--] = null;
  120.             InternalST.Soap(this, "Pop ", stackId, " ", ((obj is ITrace) ? ((ITrace)obj).Trace() : ""));
  121.             return obj;
  122.         }
  123.        
  124.         internal object Next()
  125.         {
  126.             if (next > top)
  127.                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_StackRange"), stackId));
  128.             return objects[next++];
  129.         }
  130.        
  131.         internal void IncreaseCapacity()
  132.         {
  133.             int size = objects.Length * 2;
  134.             object[] newItems = new object[size];
  135.             Array.Copy(objects, 0, newItems, 0, objects.Length);
  136.             objects = newItems;
  137.         }
  138.        
  139.         // Gets the object on the top of the stack
  140.         internal object Peek()
  141.         {
  142.             if (top < 0)
  143.                 return null;
  144.             InternalST.Soap(this, "Peek ", stackId, " ", ((objects[top] is ITrace) ? ((ITrace)objects[top]).Trace() : ""));
  145.             return objects[top];
  146.         }
  147.        
  148.         // Gets the second entry in the stack.
  149.         internal object PeekPeek()
  150.         {
  151.             if (top < 1)
  152.                 return null;
  153.             InternalST.Soap(this, "PeekPeek ", stackId, " ", ((objects[top - 1] is ITrace) ? ((ITrace)objects[top - 1]).Trace() : ""));
  154.             return objects[top - 1];
  155.         }
  156.        
  157.         // The number of entries in the stack
  158.         internal int Count()
  159.         {
  160.             return top + 1;
  161.         }
  162.        
  163.         // The number of entries in the stack
  164.         internal bool IsEmpty()
  165.         {
  166.             if (top > 0)
  167.                 return false;
  168.             else
  169.                 return true;
  170.         }
  171.        
  172.         // Reverse the stack
  173.         internal void Reverse()
  174.         {
  175.             Array.Reverse(objects, 0, Count());
  176.         }
  177.        
  178.         [Conditional("SER_LOGGING")]
  179.         internal void Dump()
  180.         {
  181.             for (int i = 0; i < Count(); i++) {
  182.                 object obj = objects[i];
  183.                 InternalST.Soap(this, "Stack Dump ", stackId, " " + ((obj is ITrace) ? ((ITrace)obj).Trace() : ""));
  184.             }
  185.         }
  186.     }
  187.    
  188.    
  189.     internal sealed class NameCacheEntry
  190.     {
  191.         internal string name;
  192.         internal object value;
  193.     }
  194.    
  195.    
  196.     internal sealed class NameCache
  197.     {
  198.         private const int MAX_CACHE_ENTRIES = 353;
  199.         // Needs to be a prime number
  200.         static NameCacheEntry[] nameCache = new NameCacheEntry[MAX_CACHE_ENTRIES];
  201.        
  202.         int probe = 0;
  203.         string name = null;
  204.        
  205.         internal object GetCachedValue(string name)
  206.         {
  207.             this.name = name;
  208.             probe = Math.Abs(name.GetHashCode()) % MAX_CACHE_ENTRIES;
  209.             NameCacheEntry entry = nameCache[probe];
  210.             if (entry == null) {
  211.                 entry = new NameCacheEntry();
  212.                 entry.name = name;
  213.                 return null;
  214.             }
  215.             else if (entry.name == name) {
  216.                 return entry.value;
  217.             }
  218.             else
  219.                 return null;
  220.         }
  221.        
  222.         internal void SetCachedValue(object value)
  223.         {
  224.             NameCacheEntry entry = new NameCacheEntry();
  225.             entry.name = name;
  226.             entry.value = value;
  227.             nameCache[probe] = entry;
  228.         }
  229.     }
  230.    
  231.    
  232.    
  233.     static internal class SoapUtil
  234.     {
  235.         static internal Type typeofString = typeof(string);
  236.         static internal Type typeofBoolean = typeof(bool);
  237.         static internal Type typeofObject = typeof(object);
  238.         static internal Type typeofSoapFault = typeof(SoapFault);
  239.         static internal Assembly urtAssembly = Assembly.GetAssembly(typeofString);
  240.         static internal string urtAssemblyString = urtAssembly.FullName;
  241.        
  242.         [Conditional("SER_LOGGING")]
  243.         static internal void DumpHash(string tag, Hashtable hashTable)
  244.         {
  245.             IDictionaryEnumerator e = hashTable.GetEnumerator();
  246.             InternalST.Soap("HashTable Dump Begin ", tag);
  247.             while (e.MoveNext()) {
  248.                 InternalST.Soap("HashTable key " + e.Key + ", value " + e.Value);
  249.             }
  250.             InternalST.Soap("HashTable Dump end \n");
  251.         }
  252.        
  253.        
  254.         static internal ResourceManager SystemResMgr;
  255.        
  256.         private static ResourceManager InitResourceManager()
  257.         {
  258.             if (SystemResMgr == null)
  259.                 SystemResMgr = new ResourceManager("SoapFormatter", typeof(SoapParser).Module.Assembly);
  260.             return SystemResMgr;
  261.         }
  262.        
  263.         // Looks up the resource string value for key.
  264.         //
  265.         static internal string GetResourceString(string key)
  266.         {
  267.             if (SystemResMgr == null)
  268.                 InitResourceManager();
  269.             string s = SystemResMgr.GetString(key, null);
  270.             InternalST.SoapAssert(s != null, "Managed resource string lookup failed. Was your resource name misspelled? Did you rebuild the SoapFormatter and SoapFormatter.resource after adding a resource to SoapFormatter.txt? Debug this w/ cordbg and bug whoever owns the code that called SoapUtil.GetResourceString. Resource name was: \"" + key + "\"");
  271.             return s;
  272.         }
  273.        
  274.         static internal string GetResourceString(string key, params object[] values)
  275.         {
  276.             if (SystemResMgr == null)
  277.                 InitResourceManager();
  278.             string s = SystemResMgr.GetString(key, null);
  279.             InternalST.SoapAssert(s != null, "Managed resource string lookup failed. Was your resource name misspelled? Did you rebuild mscorlib after adding a resource to resources.txt? Debug this w/ cordbg and bug whoever owns the code that called Environment.GetResourceString. Resource name was: \"" + key + "\"");
  280.             return String.Format(CultureInfo.CurrentCulture, s, values);
  281.         }
  282.     }
  283.    
  284.     internal sealed class SoapAssemblyInfo
  285.     {
  286.         internal string assemblyString;
  287.         private Assembly assembly;
  288.        
  289.         internal SoapAssemblyInfo(string assemblyString)
  290.         {
  291.             this.assemblyString = assemblyString;
  292.         }
  293.        
  294.         internal SoapAssemblyInfo(string assemblyString, Assembly assembly)
  295.         {
  296.             this.assemblyString = assemblyString;
  297.             this.assembly = assembly;
  298.         }
  299.        
  300.         internal Assembly GetAssembly(ObjectReader objectReader)
  301.         {
  302.             if (assembly == null) {
  303.                 assembly = objectReader.LoadAssemblyFromString(assemblyString);
  304.                 if (assembly == null)
  305.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_AssemblyString"), assemblyString));
  306.             }
  307.             return assembly;
  308.         }
  309.     }
  310.    
  311.     // The ParseRecord class holds the parsed XML information. There is a
  312.     // ParsedRecord for each XML Element
  313.     internal sealed class ParseRecord : ITrace
  314.     {
  315.         static internal int parseRecordIdCount = 1;
  316.        
  317.        
  318.         internal int PRparseRecordId = 0;
  319.        
  320.         // Enums
  321.         internal InternalParseTypeE PRparseTypeEnum = InternalParseTypeE.Empty;
  322.         internal InternalObjectTypeE PRobjectTypeEnum = InternalObjectTypeE.Empty;
  323.         internal InternalArrayTypeE PRarrayTypeEnum = InternalArrayTypeE.Empty;
  324.         internal InternalMemberTypeE PRmemberTypeEnum = InternalMemberTypeE.Empty;
  325.         internal InternalMemberValueE PRmemberValueEnum = InternalMemberValueE.Empty;
  326.         internal InternalObjectPositionE PRobjectPositionEnum = InternalObjectPositionE.Empty;
  327.        
  328.         // Object
  329.         internal string PRname;
  330.         internal string PRnameXmlKey;
  331.         internal string PRxmlNameSpace;
  332.         internal bool PRisParsed = false;
  333.         internal bool PRisProcessAttributes = false;
  334.        
  335.         // Value
  336.         internal string PRvalue;
  337.         internal object PRvarValue;
  338.        
  339.         // dt attribute
  340.         internal string PRkeyDt;
  341.         internal string PRtypeXmlKey;
  342.         internal Type PRdtType;
  343.         internal string PRassemblyName;
  344.         internal InternalPrimitiveTypeE PRdtTypeCode;
  345.         internal bool PRisVariant = false;
  346.         // Used by Binary
  347.         internal bool PRisEnum = false;
  348.        
  349.         // Object ID
  350.         internal long PRobjectId;
  351.        
  352.         // Reference ID
  353.         internal long PRidRef;
  354.        
  355.         // Array
  356.        
  357.         // Array Element Type
  358.         internal string PRarrayElementTypeString;
  359.         internal Type PRarrayElementType;
  360.         internal bool PRisArrayVariant = false;
  361.         internal InternalPrimitiveTypeE PRarrayElementTypeCode;
  362.         //internal String PRarrayXmlKey;
  363.        
  364.         // Binary Byte Array
  365.         //internal Byte[] PRbyteA;
  366.        
  367.         // Array Primitive Element type
  368.         internal string PRprimitiveArrayTypeString;
  369.        
  370.         // Parsed array information
  371.         internal int PRrank;
  372.         internal int[] PRlengthA;
  373.         internal int[] PRpositionA;
  374.         internal int[] PRlowerBoundA;
  375.         internal int[] PRupperBoundA;
  376.        
  377.         // Array map for placing array elements in array
  378.         //internal int[][] indexMap;
  379.         internal int[] PRindexMap;
  380.         internal int PRmemberIndex;
  381.         internal int PRlinearlength;
  382.         internal int[] PRrectangularMap;
  383.         internal bool PRisLowerBound;
  384.        
  385.         // SerializedStreamHeader information
  386.         internal long PRtopId;
  387.         internal long PRheaderId;
  388.         internal bool PRisHeaderRoot;
  389.         internal bool PRisAttributesProcessed;
  390.        
  391.         // Parsed HeaderMember Information
  392.         internal bool PRisMustUnderstand;
  393.        
  394.        
  395.         // Parse State
  396.         internal InternalParseStateE PRparseStateEnum = InternalParseStateE.Initial;
  397.         internal bool PRisWaitingForNestedObject = false;
  398.        
  399.         // MemberInfo accumulated during parsing of members
  400.        
  401.         internal ReadObjectInfo PRobjectInfo;
  402.        
  403.         // ValueType Fixup needed
  404.         internal bool PRisValueTypeFixup = false;
  405.        
  406.         // Created object
  407.         internal object PRnewObj;
  408.         internal object[] PRobjectA;
  409.         //optimization, will contain object[]
  410.         internal PrimitiveArray PRprimitiveArray;
  411.         // for Primitive Soap arrays, optimization
  412.         internal bool PRisRegistered;
  413.         // Used when registering nested classes
  414.         internal bool PRisXmlAttribute;
  415.        
  416.         // Get a String describing the ParseRecord
  417.        
  418.         internal ParseRecord()
  419.         {
  420.             Counter();
  421.         }
  422.        
  423.         private void Counter()
  424.         {
  425.             // The counter is used to test parseRecord identity
  426.             lock (typeof(ParseRecord)) {
  427.                 PRparseRecordId = parseRecordIdCount++;
  428.             }
  429.            
  430.         }
  431.        
  432.         public string Trace()
  433.         {
  434.             //return "ParseType "+EnumInfo.ToString(InternalParseTypeE.class, parseTypeEnum)+" name "+name+" ParseState "+EnumInfo.ToString(InternalParseStateE.class, parseStateEnum);
  435.             return "ParseRecord" + PRparseRecordId + " ParseType " + ((Enum)PRparseTypeEnum).ToString() + " name " + PRname + " keyDt " + Util.PString(PRkeyDt);
  436.         }
  437.        
  438.         // Initialize ParseRecord. Called when reusing.
  439.         internal void Init()
  440.         {
  441.             // Enums
  442.             PRparseTypeEnum = InternalParseTypeE.Empty;
  443.             PRobjectTypeEnum = InternalObjectTypeE.Empty;
  444.             PRarrayTypeEnum = InternalArrayTypeE.Empty;
  445.             PRmemberTypeEnum = InternalMemberTypeE.Empty;
  446.             PRmemberValueEnum = InternalMemberValueE.Empty;
  447.             PRobjectPositionEnum = InternalObjectPositionE.Empty;
  448.            
  449.             // Object
  450.             PRname = null;
  451.             PRnameXmlKey = null;
  452.             PRxmlNameSpace = null;
  453.             PRisParsed = false;
  454.             PRisProcessAttributes = false;
  455.            
  456.             // Value
  457.             PRvalue = null;
  458.            
  459.             // dt attribute
  460.             PRkeyDt = null;
  461.             PRdtType = null;
  462.             PRassemblyName = null;
  463.             PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
  464.             PRisEnum = false;
  465.            
  466.             // Object ID
  467.             PRobjectId = 0;
  468.            
  469.             // Reference ID
  470.             PRidRef = 0;
  471.            
  472.             // Array
  473.            
  474.             // Array Element Type
  475.             PRarrayElementTypeString = null;
  476.             PRarrayElementType = null;
  477.             PRisArrayVariant = false;
  478.             PRarrayElementTypeCode = InternalPrimitiveTypeE.Invalid;
  479.            
  480.            
  481.             // Array Primitive Element type
  482.             PRprimitiveArrayTypeString = null;
  483.            
  484.             // Parsed array information
  485.             PRrank = 0;
  486.             PRlengthA = null;
  487.             PRpositionA = null;
  488.             PRlowerBoundA = null;
  489.             PRupperBoundA = null;
  490.            
  491.             // Array map for placing array elements in array
  492.             PRindexMap = null;
  493.             PRmemberIndex = 0;
  494.             PRlinearlength = 0;
  495.             PRrectangularMap = null;
  496.             PRisLowerBound = false;
  497.            
  498.             // SerializedStreamHeader information
  499.             PRtopId = 0;
  500.             PRheaderId = 0;
  501.             PRisHeaderRoot = false;
  502.             PRisAttributesProcessed = false;
  503.            
  504.             // Parsed HeaderMember Information
  505.             PRisMustUnderstand = false;
  506.            
  507.             // Parse State
  508.             PRparseStateEnum = InternalParseStateE.Initial;
  509.             PRisWaitingForNestedObject = false;
  510.            
  511.            
  512.             // ValueType Fixup needed
  513.             PRisValueTypeFixup = false;
  514.            
  515.             PRnewObj = null;
  516.             PRobjectA = null;
  517.             PRprimitiveArray = null;
  518.             PRobjectInfo = null;
  519.             PRisRegistered = false;
  520.            
  521.             PRisXmlAttribute = false;
  522.         }
  523.        
  524.         internal ParseRecord Copy()
  525.         {
  526.            
  527.             ParseRecord newPr = new ParseRecord();
  528.             // Enums
  529.             newPr.PRparseTypeEnum = PRparseTypeEnum;
  530.             newPr.PRobjectTypeEnum = PRobjectTypeEnum;
  531.             newPr.PRarrayTypeEnum = PRarrayTypeEnum;
  532.             newPr.PRmemberTypeEnum = PRmemberTypeEnum;
  533.             newPr.PRmemberValueEnum = PRmemberValueEnum;
  534.             newPr.PRobjectPositionEnum = PRobjectPositionEnum;
  535.            
  536.             // Object
  537.             newPr.PRname = PRname;
  538.             newPr.PRisParsed = PRisParsed;
  539.             newPr.PRisProcessAttributes = PRisProcessAttributes;
  540.             newPr.PRnameXmlKey = PRnameXmlKey;
  541.             newPr.PRxmlNameSpace = PRxmlNameSpace;
  542.            
  543.             // Value
  544.             newPr.PRvalue = PRvalue;
  545.            
  546.            
  547.             // dt attribute
  548.             newPr.PRkeyDt = PRkeyDt;
  549.             newPr.PRdtType = PRdtType;
  550.             newPr.PRassemblyName = PRassemblyName;
  551.             newPr.PRdtTypeCode = PRdtTypeCode;
  552.             newPr.PRisEnum = PRisEnum;
  553.            
  554.             // Object ID
  555.             newPr.PRobjectId = PRobjectId;
  556.            
  557.             // Reference ID
  558.             newPr.PRidRef = PRidRef;
  559.            
  560.             // Array
  561.            
  562.             // Array Element Type
  563.             newPr.PRarrayElementTypeString = PRarrayElementTypeString;
  564.             newPr.PRarrayElementType = PRarrayElementType;
  565.             newPr.PRisArrayVariant = PRisArrayVariant;
  566.             newPr.PRarrayElementTypeCode = PRarrayElementTypeCode;
  567.            
  568.            
  569.             // Array Primitive Element type
  570.             newPr.PRprimitiveArrayTypeString = PRprimitiveArrayTypeString;
  571.            
  572.             // Parsed array information
  573.             newPr.PRrank = PRrank;
  574.             newPr.PRlengthA = PRlengthA;
  575.             newPr.PRpositionA = PRpositionA;
  576.             newPr.PRlowerBoundA = PRlowerBoundA;
  577.             newPr.PRupperBoundA = PRupperBoundA;
  578.            
  579.             // Array map for placing array elements in array
  580.             newPr.PRindexMap = PRindexMap;
  581.             newPr.PRmemberIndex = PRmemberIndex;
  582.             newPr.PRlinearlength = PRlinearlength;
  583.             newPr.PRrectangularMap = PRrectangularMap;
  584.             newPr.PRisLowerBound = PRisLowerBound;
  585.            
  586.             // SerializedStreamHeader information
  587.             newPr.PRtopId = PRtopId;
  588.             newPr.PRheaderId = PRheaderId;
  589.             newPr.PRisHeaderRoot = PRisHeaderRoot;
  590.             newPr.PRisAttributesProcessed = PRisAttributesProcessed;
  591.            
  592.             // Parsed HeaderMember Information
  593.             newPr.PRisMustUnderstand = PRisMustUnderstand;
  594.            
  595.             // Parse State
  596.             newPr.PRparseStateEnum = PRparseStateEnum;
  597.             newPr.PRisWaitingForNestedObject = PRisWaitingForNestedObject;
  598.            
  599.            
  600.             // ValueType Fixup needed
  601.             newPr.PRisValueTypeFixup = PRisValueTypeFixup;
  602.            
  603.             newPr.PRnewObj = PRnewObj;
  604.             newPr.PRobjectA = PRobjectA;
  605.             newPr.PRprimitiveArray = PRprimitiveArray;
  606.             newPr.PRobjectInfo = PRobjectInfo;
  607.             newPr.PRisRegistered = PRisRegistered;
  608.             newPr.PRisXmlAttribute = PRisXmlAttribute;
  609.            
  610.             return newPr;
  611.         }
  612.        
  613.        
  614.         // Dump ParseRecord.
  615.         [Conditional("SER_LOGGING")]
  616.         internal void Dump()
  617.         {
  618.             #if _DEBUG
  619.             InternalST.Soap("ParseRecord Dump ", PRparseRecordId);
  620.             InternalST.Soap("Enums");
  621.             Util.NVTrace("ParseType", ((Enum)PRparseTypeEnum).ToString());
  622.             Util.NVTrace("ObjectType", ((Enum)PRobjectTypeEnum).ToString());
  623.             Util.NVTrace("ArrayType", ((Enum)PRarrayTypeEnum).ToString());
  624.             Util.NVTrace("MemberType", ((Enum)PRmemberTypeEnum).ToString());
  625.             Util.NVTrace("MemberValue", ((Enum)PRmemberValueEnum).ToString());
  626.             Util.NVTrace("ObjectPosition", ((Enum)PRobjectPositionEnum).ToString());
  627.             Util.NVTrace("ParseState", ((Enum)PRparseStateEnum).ToString());
  628.             InternalST.Soap("Basics");
  629.             Util.NVTrace("Name", PRname);
  630.             Util.NVTrace("PRisParsed", PRisParsed);
  631.             Util.NVTrace("PRisProcessAttributes", PRisParsed);
  632.             Util.NVTrace("PRnameXmlKey", PRnameXmlKey);
  633.             Util.NVTrace("PRxmlNameSpace", PRxmlNameSpace);
  634.             Util.NVTrace("Value ", PRvalue);
  635.             Util.NVTrace("varValue ", PRvarValue);
  636.             if (PRvarValue != null)
  637.                 Util.NVTrace("varValue type", PRvarValue.GetType());
  638.            
  639.             Util.NVTrace("keyDt", PRkeyDt);
  640.             Util.NVTrace("dtType", PRdtType);
  641.             Util.NVTrace("assemblyName", PRassemblyName);
  642.             Util.NVTrace("code", ((Enum)PRdtTypeCode).ToString());
  643.             Util.NVTrace("objectID", PRobjectId);
  644.             Util.NVTrace("idRef", PRidRef);
  645.             Util.NVTrace("isEnum", PRisEnum);
  646.             InternalST.Soap("Array ");
  647.             Util.NVTrace("arrayElementTypeString", PRarrayElementTypeString);
  648.             Util.NVTrace("arrayElementType", PRarrayElementType);
  649.             Util.NVTrace("arrayElementTypeCode", ((Enum)PRarrayElementTypeCode).ToString());
  650.             Util.NVTrace("isArrayVariant", PRisArrayVariant);
  651.             Util.NVTrace("primitiveArrayTypeString", PRprimitiveArrayTypeString);
  652.             Util.NVTrace("rank", PRrank);
  653.             Util.NVTrace("dimensions", Util.PArray(PRlengthA));
  654.             Util.NVTrace("position", Util.PArray(PRpositionA));
  655.             Util.NVTrace("lowerBoundA", Util.PArray(PRlowerBoundA));
  656.             Util.NVTrace("upperBoundA", Util.PArray(PRupperBoundA));
  657.             InternalST.Soap("Header ");
  658.             Util.NVTrace("isMustUnderstand", PRisMustUnderstand);
  659.             Util.NVTrace("isHeaderRoot", PRisHeaderRoot);
  660.             Util.NVTrace("isAttributesProcessed", PRisAttributesProcessed);
  661.             Util.NVTrace("isXmlAttribute", PRisXmlAttribute);
  662.            
  663.             InternalST.Soap("New Object");
  664.             if (PRnewObj != null)
  665.                 Util.NVTrace("newObj", PRnewObj);
  666.             /*
  667. if ((objectInfo != null) && (objectInfo.objectType != null))
  668. Util.NVTrace("objectInfo", objectInfo.objectType.ToString());
  669. */           
  670.             #endif
  671.         }
  672.     }
  673.    
  674.     internal interface ITrace
  675.     {
  676.         string Trace();
  677.     }
  678.    
  679.     // Utilities
  680.     static internal class Util
  681.     {
  682.        
  683.         // Replaces a null string with an empty string
  684.         static internal string PString(string value)
  685.         {
  686.             if (value == null)
  687.                 return "";
  688.             else
  689.                 return value;
  690.         }
  691.        
  692.         #if _DEBUG
  693.         // Converts an object to a string and checks for nulls
  694.         static internal string PString(object value)
  695.         {
  696.             if (value == null)
  697.                 return "";
  698.             else
  699.                 return value.ToString();
  700.         }
  701.        
  702.         // Converts a single int array to a string
  703.        
  704.         static internal string PArray(int[] array)
  705.         {
  706.             if (array != null) {
  707.                 StringBuilder sb = new StringBuilder(10);
  708.                 sb.Append("[");
  709.                 for (int i = 0; i < array.Length; i++) {
  710.                     sb.Append(array[i]);
  711.                     if (i != array.Length - 1)
  712.                         sb.Append(",");
  713.                 }
  714.                 sb.Append("]");
  715.                 return sb.ToString();
  716.             }
  717.             else
  718.                 return "";
  719.         }
  720.         #endif
  721.        
  722.         // Traces a name value pair
  723.        
  724.         [Conditional("SER_LOGGING")]
  725.         static internal void NVTrace(string name, string value)
  726.         {
  727.             InternalST.Soap(" " + name + ((value == null) ? " = null" : " = " + value));
  728.         }
  729.        
  730.         // Traces a name value pair
  731.         [Conditional("SER_LOGGING")]
  732.         static internal void NVTrace(string name, object value)
  733.         {
  734.             try {
  735.                 InternalST.Soap(" " + name + ((value == null) ? " = null" : " = " + value.ToString()));
  736.             }
  737.             catch {
  738.                 InternalST.Soap(" " + name + " = null");
  739.                 //Empty StringBuilder is giving an exception
  740.             }
  741.         }
  742.        
  743.         // Traces a name value pair
  744.        
  745.         [Conditional("_LOGGING")]
  746.         static internal void NVTraceI(string name, string value)
  747.         {
  748.             InternalST.Soap(" " + name + ((value == null) ? " = null" : " = " + value));
  749.         }
  750.        
  751.         // Traces a name value pair
  752.         [Conditional("_LOGGING")]
  753.         static internal void NVTraceI(string name, object value)
  754.         {
  755.             InternalST.Soap(" " + name + ((value == null) ? " = null" : " = " + value.ToString()));
  756.         }
  757.        
  758.     }
  759.    
  760.    
  761.     // Used to fixup value types. Only currently used for value types which are array items.
  762.     internal class ValueFixup : ITrace
  763.     {
  764.         internal ValueFixupEnum valueFixupEnum = ValueFixupEnum.Empty;
  765.         internal Array arrayObj;
  766.         internal int[] indexMap;
  767.         internal object memberObject;
  768.         internal ReadObjectInfo objectInfo;
  769.         internal string memberName;
  770.        
  771.         internal ValueFixup(Array arrayObj, int[] indexMap)
  772.         {
  773.             InternalST.Soap(this, "Array Constructor ", arrayObj);
  774.             valueFixupEnum = ValueFixupEnum.Array;
  775.             this.arrayObj = arrayObj;
  776.             this.indexMap = indexMap;
  777.         }
  778.        
  779.         internal ValueFixup(object memberObject, string memberName, ReadObjectInfo objectInfo)
  780.         {
  781.             InternalST.Soap(this, "Member Constructor ", memberObject);
  782.             valueFixupEnum = ValueFixupEnum.Member;
  783.             this.memberObject = memberObject;
  784.             this.memberName = memberName;
  785.             this.objectInfo = objectInfo;
  786.         }
  787.        
  788.         internal virtual void Fixup(ParseRecord record, ParseRecord parent)
  789.         {
  790.             object obj = record.PRnewObj;
  791.             InternalST.Soap(this, "Fixup ", obj, " ", ((Enum)valueFixupEnum).ToString());
  792.            
  793.             switch (valueFixupEnum) {
  794.                 case ValueFixupEnum.Array:
  795.                     arrayObj.SetValue(obj, indexMap);
  796.                     break;
  797.                 case ValueFixupEnum.Member:
  798.                    
  799.                     InternalST.Soap(this, "Fixup Member new object value ", obj, " memberObject ", memberObject);
  800.                    
  801.                     if (objectInfo.isSi) {
  802.                         InternalST.Soap(this, "Recording a fixup on member: ", memberName, " in object id", parent.PRobjectId, " Required Object ", record.PRobjectId);
  803.                         objectInfo.objectManager.RecordDelayedFixup(parent.PRobjectId, memberName, record.PRobjectId);
  804.                     }
  805.                     else {
  806.                         MemberInfo memberInfo = objectInfo.GetMemberInfo(memberName);
  807.                         InternalST.Soap(this, "Recording a fixup on member:", memberInfo, " in object id ", parent.PRobjectId, " Required Object", record.PRobjectId);
  808.                         objectInfo.objectManager.RecordFixup(parent.PRobjectId, memberInfo, record.PRobjectId);
  809.                     }
  811.                     break;
  812.             }
  813.         }
  814.        
  815.         public virtual string Trace()
  816.         {
  817.             return "ValueFixup" + ((Enum)valueFixupEnum).ToString();
  818.         }
  819.        
  820.     }
  821.    
  822.     // Class used to transmit Enums from the XML and Binary Formatter class to the ObjectWriter and ObjectReader class
  823.     internal sealed class InternalFE
  824.     {
  825.         internal FormatterTypeStyle FEtypeFormat;
  826.         internal FormatterAssemblyStyle FEassemblyFormat;
  827.         internal ISoapMessage FEtopObject;
  828.         internal TypeFilterLevel FEsecurityLevel;
  829.         internal InternalSerializerTypeE FEserializerTypeEnum;
  830.     }
  831.    
  832.     // Class used to Read an XML record which has a fake object as the top object.
  833.     // A fake object is an object which has the methodName as the XML elementName rather
  834.     // then a valid object name.
  835.     // After the information is read a SoapMessage object is created as the top object
  836.     // to return the information as the top object graph
  837.     [Serializable()]
  838.     internal sealed class InternalSoapMessage : ISerializable, IFieldInfo
  839.     {
  840.         internal string methodName = null;
  841.         internal string xmlNameSpace = null;
  842.         internal string[] paramNames = null;
  843.         internal object[] paramValues = null;
  844.         internal Type[] paramTypes = null;
  845.         internal Hashtable keyToNamespaceTable = null;
  846.        
  847.         // Read Constructor
  848.         internal InternalSoapMessage()
  849.         {
  850.             InternalST.Soap(this, "Constructor Read Unitialized ");
  851.         }
  852.        
  853.         // Write Constructor
  854.         internal InternalSoapMessage(string methodName, string xmlNameSpace, string[] paramNames, object[] paramValues, Type[] paramTypes)
  855.         {
  856.             InternalST.Soap(this, "Constructor Write ", methodName);
  857.             this.methodName = methodName;
  858.             this.xmlNameSpace = xmlNameSpace;
  859.             this.paramNames = paramNames;
  860.             this.paramValues = paramValues;
  861.             this.paramTypes = paramTypes;
  862.         }
  863.        
  864.         internal InternalSoapMessage(SerializationInfo info, StreamingContext context)
  865.         {
  866.             InternalST.Soap(this, "Constructor Write SetObjectData ");
  867.             SetObjectData(info, context);
  868.         }
  869.        
  870.         // IFieldInfo
  871.         public string[] FieldNames {
  872.             get { return paramNames; }
  873.             set { paramNames = value; }
  874.         }
  875.        
  876.         // IFieldInfo
  877.         public Type[] FieldTypes {
  878.             get { return paramTypes; }
  879.             set { paramTypes = value; }
  880.         }
  881.        
  882.        
  883.         public void GetObjectData(SerializationInfo info, StreamingContext context)
  884.         {
  885.            
  886.             int numberOfMembers = 0;
  887.            
  888.             if (paramValues != null)
  889.                 numberOfMembers = paramValues.Length;
  890.            
  891.             InternalST.Soap(this, "GetObjectData ", methodName, " " + numberOfMembers);
  892.            
  893.             info.FullTypeName = methodName;
  894.             if (xmlNameSpace != null)
  895.                 info.AssemblyName = xmlNameSpace;
  896.            
  897.             string paramName = null;
  898.             if (paramValues != null) {
  899.                 for (int i = 0; i < paramValues.Length; i++) {
  900.                     InternalST.Soap(this, "GetObjectData AddValue ", paramNames[i], " ", paramValues[i]);
  901.                    
  902.                     if ((paramNames != null) && (paramNames[i] == null))
  903.                         paramName = "param" + i;
  904.                     else
  905.                         paramName = paramNames[i];
  906.                     info.AddValue(paramName, paramValues[i], typeof(object));
  907.                 }
  908.             }
  909.            
  910.         }
  911.        
  912.         internal void SetObjectData(SerializationInfo info, StreamingContext context)
  913.         {
  914.             InternalST.Soap(this, "SetObjectData ");
  915.             ArrayList paramValuesList = new ArrayList(20);
  916.             methodName = (string)info.GetString("__methodName");
  917.             keyToNamespaceTable = (Hashtable)info.GetValue("__keyToNamespaceTable", typeof(Hashtable));
  918.             ArrayList paramNamesList = (ArrayList)info.GetValue("__paramNameList", typeof(ArrayList));
  919.             xmlNameSpace = (string)info.GetString("__xmlNameSpace");
  920.            
  921.             for (int i = 0; i < paramNamesList.Count; i++)
  922.                 paramValuesList.Add(info.GetValue((string)paramNamesList[i], Converter.typeofObject));
  923.            
  924.             paramNames = new string[paramNamesList.Count];
  925.             paramValues = new object[paramValuesList.Count];
  926.            
  927.             for (int i = 0; i < paramNamesList.Count; i++) {
  928.                 paramNames[i] = (string)paramNamesList[i];
  929.                 paramValues[i] = (object)paramValuesList[i];
  930.                 InternalST.Soap(this, "SetObjectData param ", i, " ", paramNames[i], " paramValue ", paramValues[i]);
  931.             }
  932.         }
  933.     }
  934.    
  935.     internal sealed class SoapAttributeInfo
  936.     {
  937.         internal SoapAttributeType m_attributeType;
  938.         internal string m_nameSpace;
  939.         internal string m_elementName;
  940.         internal string m_typeName;
  941.         internal string m_typeNamespace;
  942.        
  943.         inter