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 \ AttributeValueEntry

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: SoapParser
  18. // Purpose: XML Handlers for System.XML parser
  19. //
  20. // Date: June 10, 1999
  21. //
  22. //============================================================
  24. namespace System.Runtime.Serialization.Formatters.Soap
  25. {
  26.     using System;
  27.     using System.Runtime.Serialization.Formatters;
  28.     using System.Xml;
  29.     using System.IO;
  30.     using System.Globalization;
  31.     using System.Collections;
  32.     using System.Reflection;
  33.     using System.Runtime.Serialization;
  34.     using System.Text;
  35.     using System.Runtime.Remoting;
  36.     using System.Runtime.Remoting.Messaging;
  37.     using System.Runtime.Remoting.Metadata;
  38.    
  39.    
  40.     internal sealed class SoapParser : ISerParser
  41.     {
  42.         internal XmlTextReader xmlReader;
  43.         internal SoapHandler soapHandler;
  44.         internal ObjectReader objectReader;
  45.         internal bool bStop = false;
  46.         int depth = 0;
  47.         bool bDebug = false;
  48.         TextReader textReader = null;
  49.        
  50.         internal SoapParser(Stream stream)
  51.         {
  52.             InternalST.Soap(this, "Constructor");
  53.             TraceStream(stream);
  54.             if (bDebug)
  55.                 xmlReader = new XmlTextReader(textReader);
  56.             else
  57.                 xmlReader = new XmlTextReader(stream);
  58.             xmlReader.XmlResolver = null;
  59.             xmlReader.ProhibitDtd = true;
  60.             soapHandler = new SoapHandler(this);
  61.         }
  62.        
  63.        
  64.         // Trace when checked builds
  65.         [System.Diagnostics.Conditional("_LOGGING")]
  66.         private void TraceStream(Stream stream)
  67.         {
  68.             bDebug = true;
  69.             TextReader tempReader = new StreamReader(stream);
  70.             string strbuffer = tempReader.ReadToEnd();
  71.             InternalST.InfoSoap("******************** Begin Deserialized Stream Buffer *******************");
  72.             InternalST.InfoSoap(strbuffer);
  73.             InternalST.InfoSoap("******************** End Deserialized Stream Buffer *******************");
  74.             textReader = new StringReader(strbuffer);
  75.         }
  76.        
  77.        
  78.         internal void Init(ObjectReader objectReader)
  79.         {
  80.             InternalST.Soap(this, "Init");
  81.             this.objectReader = objectReader;
  82.             soapHandler.Init(objectReader);
  83.             bStop = false;
  84.             depth = 0;
  85.             xmlReader.ResetState();
  86.         }
  87.        
  88.         // Start parsing the input
  89.         public void Run()
  90.         {
  91.             InternalST.Soap(this, "Run");
  92.             try {
  93.                 soapHandler.Start(xmlReader);
  94.                 ParseXml();
  95.             }
  96.             catch (EndOfStreamException) {
  97.             }
  98.         }
  99.        
  100.         internal void Stop()
  101.         {
  102.             InternalST.Soap(this, "Stop");
  103.             bStop = true;
  104.         }
  105.        
  106.        
  107.         private void ParseXml()
  108.         {
  109.             InternalST.Soap(this, "ParseXml");
  110.             while (!bStop && xmlReader.Read()) {
  111.                 if (depth < xmlReader.Depth) {
  112.                     soapHandler.StartChildren();
  113.                     depth = xmlReader.Depth;
  114.                 }
  115.                 else if (depth > xmlReader.Depth) {
  116.                     soapHandler.FinishChildren(xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI);
  117.                     depth = xmlReader.Depth;
  118.                 }
  119.                
  120.                 switch (xmlReader.NodeType) {
  121.                     case (XmlNodeType.None):
  122.                         break;
  123.                     case (XmlNodeType.Element):
  124.                         Dump("Node Element", xmlReader);
  125.                         soapHandler.StartElement(xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI);
  126.                         int attributeCount = xmlReader.AttributeCount;
  127.                         while (xmlReader.MoveToNextAttribute()) {
  128.                             soapHandler.Attribute(xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI, xmlReader.Value);
  129.                         }
  131.                         xmlReader.MoveToElement();
  132.                         if (xmlReader.IsEmptyElement)
  133.                             soapHandler.EndElement(xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI);
  135.                         break;
  136.                     case XmlNodeType.EndElement:
  137.                         Dump("Node EndElement", xmlReader);
  138.                         soapHandler.EndElement(xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI);
  139.                         break;
  140.                     case (XmlNodeType.Text):
  141.                         Dump("Node Text", xmlReader);
  142.                         soapHandler.Text(xmlReader.Value);
  143.                         break;
  144.                     case (XmlNodeType.SignificantWhitespace):
  145.                         Dump("Node SignificantWhitespace", xmlReader);
  146.                         soapHandler.Text(xmlReader.Value);
  147.                         break;
  148.                     case (XmlNodeType.Whitespace):
  149.                         Dump("Node Whitespace", xmlReader);
  150.                         soapHandler.Text(xmlReader.Value);
  151.                         break;
  152.                     case (XmlNodeType.Entity):
  153.                         Dump("Node Entity", xmlReader);
  154.                         break;
  155.                     case (XmlNodeType.CDATA):
  156.                         Dump("Node CDATA", xmlReader);
  157.                         soapHandler.Text(xmlReader.Value);
  158.                         break;
  159.                     case (XmlNodeType.Comment):
  160.                         Dump("Node Comment", xmlReader);
  161.                         soapHandler.Comment(xmlReader.Value);
  162.                         break;
  163.                     case (XmlNodeType.EntityReference):
  164.                         Dump("Node EntityReference", xmlReader);
  165.                         break;
  166.                     case (XmlNodeType.ProcessingInstruction):
  167.                         Dump("Node ProcessingInstruction", xmlReader);
  168.                         break;
  169.                     case (XmlNodeType.Document):
  170.                         Dump("Node Document", xmlReader);
  171.                         break;
  172.                     case (XmlNodeType.DocumentType):
  173.                         Dump("Node DocumentType", xmlReader);
  174.                         break;
  175.                     case (XmlNodeType.DocumentFragment):
  176.                         Dump("Node DocumentFragment", xmlReader);
  177.                         break;
  178.                     case (XmlNodeType.Notation):
  179.                         Dump("Node Notation", xmlReader);
  180.                         break;
  181.                     case (XmlNodeType.EndEntity):
  182.                         Dump("Node EndEntity", xmlReader);
  183.                         break;
  184.                     default:
  185.                         Dump("Node Default", xmlReader);
  186.                         break;
  187.                 }
  188.                
  189.             }
  190.         }
  191.        
  192.         [System.Diagnostics.Conditional("SER_LOGGING")]
  193.         private static void Dump(string name, XmlReader xmlReader)
  194.         {
  195.             InternalST.Soap("========== " + name + " ============");
  196.             InternalST.Soap("Prefix : " + xmlReader.Prefix);
  197.             InternalST.Soap("Name : " + xmlReader.Name);
  198.             InternalST.Soap("LocalName : " + xmlReader.LocalName);
  199.             InternalST.Soap("Namespace : " + xmlReader.NamespaceURI);
  200.             InternalST.Soap("Depth : " + xmlReader.Depth);
  201.             InternalST.Soap("Value : [" + xmlReader.Value + "]");
  202.             InternalST.Soap("IsDefault : " + xmlReader.IsDefault);
  203.             InternalST.Soap("XmlSpace : " + xmlReader.XmlSpace);
  204.             InternalST.Soap("XmlLang : " + xmlReader.XmlLang);
  205.             InternalST.Soap("QuoteChar : " + xmlReader.QuoteChar);
  206.             InternalST.Soap("================================\n");
  207.         }
  208.        
  209.     }
  210.    
  211.     // Sets the handler which contains the callbacks for the parser
  212.     internal sealed class SoapHandler
  213.     {
  214.         SerStack stack = new SerStack("SoapParser Stack");
  215.        
  216.         XmlTextReader xmlTextReader = null;
  217.         SoapParser soapParser = null;
  218.        
  219.        
  220.         // Current text
  221.         string textValue = "";
  222.        
  223.         // XML Formatter
  224.         ObjectReader objectReader;
  225.         internal Hashtable keyToNamespaceTable;
  226.         //needed for xsd QName type
  227.         // Current state
  228.         InternalParseStateE currentState;
  229.         bool isEnvelope = false;
  230.         bool isBody = false;
  231.         bool isTopFound = false;
  232.         HeaderStateEnum headerState = HeaderStateEnum.None;
  233.        
  234.         // Attribute holder
  235.         SerStack attributeValues = new SerStack("AttributePrefix");
  236.        
  237.         SerStack prPool = new SerStack("prPool");
  238.        
  239.         // XML Key to AssemblyId table
  240.         // Key of SOAP has an AssemblyId of -1
  241.         // Key of urt has an AssemblyId of -2
  242.         Hashtable assemKeyToAssemblyTable = null;
  243.         Hashtable assemKeyToNameSpaceTable = null;
  244.         Hashtable assemKeyToInteropAssemblyTable = null;
  245.         Hashtable nameSpaceToKey = null;
  246.         // Used to assign a key to default xml namespaces
  247.         string soapKey = "SOAP-ENC";
  248.         //xml key for soap, should be SOAP
  249.         string urtKey = "urt";
  250.         //xml key for urt, should be urt
  251.         string soapEnvKey = "SOAP-ENV";
  252.         //xml key for SOAPRENV, initial value, might change
  253.         string xsiKey = "xsi";
  254.         //xml key for xsi, initial value, might change
  255.         string xsdKey = "xsd";
  256.         //xml key for xsd, initial value, might change
  257.         int nextPrefix = 0;
  258.         // Used to generate a prefix if necessary
  259.         internal SoapHandler(SoapParser soapParser)
  260.         {
  261.             this.soapParser = soapParser;
  262.         }
  263.        
  264.         internal void Init(ObjectReader objectReader)
  265.         {
  266.             this.objectReader = objectReader;
  267.             objectReader.soapHandler = this;
  268.             isEnvelope = false;
  269.             isBody = false;
  270.             isTopFound = false;
  271.             attributeValues.Clear();
  272.             assemKeyToAssemblyTable = new Hashtable(10);
  273.             assemKeyToAssemblyTable[urtKey] = new SoapAssemblyInfo(SoapUtil.urtAssemblyString, SoapUtil.urtAssembly);
  274.             assemKeyToNameSpaceTable = new Hashtable(10);
  275.             assemKeyToInteropAssemblyTable = new Hashtable(10);
  276.             nameSpaceToKey = new Hashtable(5);
  277.             keyToNamespaceTable = new Hashtable(10);
  278.            
  279.         }
  280.        
  281.         private string NextPrefix()
  282.         {
  283.             nextPrefix++;
  284.             return "_P" + nextPrefix;
  285.            
  286.         }
  287.        
  288.         internal class AttributeValueEntry
  289.         {
  290.             internal string prefix;
  291.             internal string key;
  292.             internal string value;
  293.             internal string urn;
  294.            
  295.             internal AttributeValueEntry(string prefix, string key, string value, string urn)
  296.             {
  297.                 this.prefix = prefix;
  298.                 this.key = key;
  299.                 this.value = value;
  300.                 this.urn = urn;
  301.             }
  302.         }
  303.        
  304.         private ParseRecord GetPr()
  305.         {
  306.             ParseRecord pr = null;
  307.            
  308.             if (!prPool.IsEmpty()) {
  309.                 pr = (ParseRecord)prPool.Pop();
  310.                 pr.Init();
  311.             }
  312.             else
  313.                 pr = new ParseRecord();
  314.            
  315.             return pr;
  316.         }
  317.        
  318.         private void PutPr(ParseRecord pr)
  319.         {
  320.             prPool.Push(pr);
  321.         }
  322.        
  323.         // Creates a trace string
  324.         private static string SerTraceString(string handler, ParseRecord pr, string value, InternalParseStateE currentState, HeaderStateEnum headerState)
  325.         {
  326.             string valueString = "";
  327.             if (value != null)
  328.                 valueString = value;
  329.            
  330.             string prString = "";
  331.             if (pr != null)
  332.                 prString = ((Enum)pr.PRparseStateEnum).ToString();
  333.            
  334.             return handler + " - " + valueString + ", State " + ((Enum)currentState).ToString() + ", PushState " + prString;
  335.         }
  336.        
  337.         #if _DEBUG
  338.         private static string SerTraceString(string handler, ParseRecord pr, string value, string prefix, string urn, InternalParseStateE currentState, HeaderStateEnum headerState)
  339.         {
  340.             string valueString = "";
  341.             if (value != null)
  342.                 valueString = value;
  343.            
  344.             string prString = "";
  345.             if (pr != null)
  346.                 prString = ((Enum)pr.PRparseStateEnum).ToString();
  347.            
  348.             return handler + " - name " + valueString + ", prefix " + prefix + ", urn " + urn + ", CuurentState " + ((Enum)currentState).ToString() + ", HeaderState " + ((Enum)headerState).ToString() + ", PushState " + prString;
  349.         }
  350.         #endif
  351.        
  352.        
  353.         // Formats the error message and throws a SerializationException
  354.         private void MarshalError(string handler, ParseRecord pr, string value, InternalParseStateE currentState)
  355.         {
  356.             string traceString = SerTraceString(handler, pr, value, currentState, headerState);
  357.             #if _DEBUG
  358.             InternalST.Soap(this, "MarshalError,", traceString);
  359.             #endif
  360.             throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_Syntax"), traceString));
  361.         }
  362.        
  363.         // Called at the beginning of parsing
  364.         internal void Start(XmlTextReader p)
  365.         {
  366.             InternalST.Soap(this, "Start ");
  367.             currentState = InternalParseStateE.Object;
  368.             xmlTextReader = p;
  369.         }
  370.        
  371.         // Called at the begining of an element
  372.         internal void StartElement(string prefix, string name, string urn)
  373.         {
  374.             #if _DEBUG
  375.             InternalST.Soap(this, SerTraceString("StartElement Begin ", (ParseRecord)stack.Peek(), name, prefix, urn, currentState, headerState));
  376.             #endif
  377.             string actualName = NameFilter(name);
  378.             string actualPrefix = prefix;
  379.            
  380.             ParseRecord pr = null;
  381.            
  382.             if (!((urn == null) || (urn.Length == 0)) && ((prefix == null) || (prefix.Length == 0))) {
  383.                 // Need to assign a prefix to the urn
  384.                 if (nameSpaceToKey.ContainsKey(urn))
  385.                     actualPrefix = (string)nameSpaceToKey[urn];
  386.                 else {
  387.                     actualPrefix = NextPrefix();
  388.                     nameSpaceToKey[urn] = actualPrefix;
  389.                 }
  390.                 InternalST.Soap(this, "StartElement Begin null urn assigned prefix ", actualPrefix);
  391.             }
  392.            
  393.            
  394.             switch (currentState) {
  395.                 case InternalParseStateE.Object:
  396.                     pr = GetPr();
  397.                     pr.PRname = actualName;
  398.                     pr.PRnameXmlKey = actualPrefix;
  399.                     pr.PRxmlNameSpace = urn;
  400.                     pr.PRparseStateEnum = InternalParseStateE.Object;
  401.                    
  402.                     if ((String.Compare(name, "Array", StringComparison.OrdinalIgnoreCase) == 0) && actualPrefix.Equals(soapKey))
  403.                         pr.PRparseTypeEnum = InternalParseTypeE.Object;
  404.                     else if (((String.Compare(name, "anyType", StringComparison.OrdinalIgnoreCase) == 0) || (String.Compare(name, "ur-type", StringComparison.OrdinalIgnoreCase) == 0)) && actualPrefix.Equals(xsdKey)) {
  405.                         pr.PRname = "System.Object";
  406.                         pr.PRnameXmlKey = urtKey;
  407.                         pr.PRxmlNameSpace = urn;
  408.                         pr.PRparseTypeEnum = InternalParseTypeE.Object;
  409.                     }
  410.                     else if (String.Compare(urn, "http://schemas.xmlsoap.org/soap/envelope/", StringComparison.OrdinalIgnoreCase) == 0) {
  411.                         if (String.Compare(name, "Envelope", StringComparison.OrdinalIgnoreCase) == 0) {
  412.                             if (isEnvelope)
  413.                                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_Parser_Envelope"), prefix + ":" + name));
  414.                            
  415.                             isEnvelope = true;
  416.                             pr.PRparseTypeEnum = InternalParseTypeE.Envelope;
  417.                         }
  418.                         else if (String.Compare(name, "Body", StringComparison.OrdinalIgnoreCase) == 0) {
  419.                             if (!isEnvelope)
  420.                                 throw new SerializationException(SoapUtil.GetResourceString("Serialization_Parser_BodyChild"));
  421.                            
  422.                             if (isBody)
  423.                                 throw new SerializationException(SoapUtil.GetResourceString("Serialization_Parser_BodyOnce"));
  424.                            
  425.                             isBody = true;
  426.                             headerState = HeaderStateEnum.None;
  427.                             isTopFound = false;
  428.                             pr.PRparseTypeEnum = InternalParseTypeE.Body;
  429.                         }
  430.                         else if (String.Compare(name, "Header", StringComparison.OrdinalIgnoreCase) == 0) {
  431.                             if (!isEnvelope)
  432.                                 throw new SerializationException(SoapUtil.GetResourceString("Serialization_Parser_Header"));
  433.                            
  434.                             pr.PRparseTypeEnum = InternalParseTypeE.Headers;
  435.                             headerState = HeaderStateEnum.FirstHeaderRecord;
  436.                         }
  437.                         else
  438.                             pr.PRparseTypeEnum = InternalParseTypeE.Object;
  439.                         //SoapFault has an envelope key
  440.                     }
  441.                     else {
  442.                         pr.PRparseTypeEnum = InternalParseTypeE.Object;
  443.                     }
  445.                    
  446.                     stack.Push(pr);
  447.                     break;
  448.                 case InternalParseStateE.Member:
  449.                    
  450.                     pr = GetPr();
  451.                    
  452.                     // Members of Top object records cannot be reused because of the need to resolving fake element
  453.                     ParseRecord objectPr = (ParseRecord)stack.Peek();
  454.                     pr.PRname = actualName;
  455.                     pr.PRnameXmlKey = actualPrefix;
  456.                     pr.PRxmlNameSpace = urn;
  457.                     pr.PRparseTypeEnum = InternalParseTypeE.Member;
  458.                     pr.PRparseStateEnum = InternalParseStateE.Member;
  459.                     stack.Push(pr);
  460.                     break;
  461.                 case InternalParseStateE.MemberChild:
  462.                    
  463.                     objectPr = (ParseRecord)stack.PeekPeek();
  464.                     pr = (ParseRecord)stack.Peek();
  465.                     pr.PRmemberValueEnum = InternalMemberValueE.Nested;
  466.                     ProcessAttributes(pr, objectPr);
  467.                     switch (headerState) {
  468.                         case HeaderStateEnum.None:
  469.                         case HeaderStateEnum.TopLevelObject:
  470.                             InternalST.Soap(this, "ObjectReader.Parse 1");
  471.                             objectReader.Parse(pr);
  472.                             pr.PRisParsed = true;
  473.                             break;
  474.                         case HeaderStateEnum.HeaderRecord:
  475.                         case HeaderStateEnum.NestedObject:
  476.                             ProcessHeaderMember(pr);
  477.                             break;
  478.                     }
  479.                    
  480.                     ParseRecord nestPr = GetPr();
  481.                     nestPr.PRparseTypeEnum = InternalParseTypeE.Member;
  482.                     nestPr.PRparseStateEnum = InternalParseStateE.Member;
  483.                     nestPr.PRname = actualName;
  484.                     nestPr.PRnameXmlKey = actualPrefix;
  485.                     pr.PRxmlNameSpace = urn;
  486.                     currentState = InternalParseStateE.Member;
  487.                     stack.Push(nestPr);
  488.                     break;
  489.                 default:
  490.                    
  491.                     MarshalError("StartElement", (ParseRecord)stack.Peek(), actualName, currentState);
  492.                     break;
  493.             }
  494.            
  495.             #if _DEBUG
  496.             InternalST.Soap(this, SerTraceString("StartElement End ", (ParseRecord)stack.Peek(), name, currentState, headerState));
  497.             #endif
  498.         }
  499.        
  500.        
  501.         // Called at the end of an element
  502.         internal void EndElement(string prefix, string name, string urn)
  503.         {
  504.             #if _DEBUG
  505.             InternalST.Soap(this, SerTraceString("EndElement Begin ", (ParseRecord)stack.Peek(), name, prefix, urn, currentState, headerState));
  506.             #endif
  507.            
  508.             string actualName = NameFilter(name);
  509.            
  510.             ParseRecord objectPr = null;
  511.             ParseRecord pr = null;
  512.            
  513.             switch (currentState) {
  514.                 case InternalParseStateE.Object:
  515.                     pr = (ParseRecord)stack.Pop();
  516.                     if (pr.PRparseTypeEnum == InternalParseTypeE.Envelope)
  517.                         pr.PRparseTypeEnum = InternalParseTypeE.EnvelopeEnd;
  518.                     else if (pr.PRparseTypeEnum == InternalParseTypeE.Body)
  519.                         pr.PRparseTypeEnum = InternalParseTypeE.BodyEnd;
  520.                     else if (pr.PRparseTypeEnum == InternalParseTypeE.Headers) {
  521.                         pr.PRparseTypeEnum = InternalParseTypeE.HeadersEnd;
  522.                         headerState = HeaderStateEnum.HeaderRecord;
  523.                     }
  524.                     else if (pr.PRarrayTypeEnum != InternalArrayTypeE.Base64) {
  525.                         // A Base64 array object treated special by ObjectReader. It is completely processed when
  526.                         // pr.PRparseTypeEnum == InternalParseTypeE.Object, an ObjectEnd is not needed to complete parsing
  527.                        
  528.                         // For an element like <element />, the check was not made for top
  529.                         objectPr = (ParseRecord)stack.Peek();
  530.                         InternalST.Soap(this, "SoapParser.EndElement TopFound " + isTopFound + " objectPr.parseTypeEnum " + (objectPr == null ? "null" : ((Enum)objectPr.PRparseTypeEnum).ToString()));
  531.                         if (!isTopFound && (objectPr != null) && (objectPr.PRparseTypeEnum == InternalParseTypeE.Body)) {
  532.                             pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
  533.                             isTopFound = true;
  534.                             InternalST.Soap(this, "SoapParser.EndElement change position to top");
  535.                         }
  536.                        
  537.                         if (!pr.PRisParsed) {
  538.                             InternalST.Soap(this, "SoapParser.EndElement Object hasn't been parsed");
  539.                             if (!pr.PRisProcessAttributes && !(pr.PRobjectPositionEnum == InternalObjectPositionE.Top && objectReader.IsFakeTopObject))
  540.                                 ProcessAttributes(pr, objectPr);
  541.                             objectReader.Parse(pr);
  542.                             pr.PRisParsed = true;
  543.                         }
  544.                         pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
  545.                     }
  547.                    
  548.                     switch (headerState) {
  549.                         case HeaderStateEnum.None:
  550.                         case HeaderStateEnum.TopLevelObject:
  551.                             InternalST.Soap(this, "SoapParser.EndElement Parse EndObject");
  552.                             objectReader.Parse(pr);
  553.                             break;
  554.                         case HeaderStateEnum.HeaderRecord:
  555.                         case HeaderStateEnum.NestedObject:
  556.                             InternalST.Soap(this, "SoapParser.EndElement ProcessHeaderEnd");
  557.                             ProcessHeaderEnd(pr);
  558.                             break;
  559.                     }
  560.                    
  561.                     if (pr.PRparseTypeEnum == InternalParseTypeE.EnvelopeEnd) {
  562.                         // End of document
  563.                         soapParser.Stop();
  564.                     }
  566.                    
  567.                     PutPr(pr);
  568.                     break;
  569.                 case InternalParseStateE.Member:
  570.                    
  571.                     pr = (ParseRecord)stack.Peek();
  572.                     objectPr = (ParseRecord)stack.PeekPeek();
  573.                     ProcessAttributes(pr, objectPr);
  574.                    
  575.                     // Check if there are any XmlAttribute records, if there are, process them
  576.                     if (xmlAttributeList != null)
  577.                         InternalST.Soap(this, "XmlAttribute check count ", xmlAttributeList.Count);
  578.                     else
  579.                         InternalST.Soap(this, "XmlAttribute null");
  581.                    
  582.                     if ((xmlAttributeList != null) && (xmlAttributeList.Count > 0)) {
  583.                         InternalST.Soap(this, "xmlAttribute list count ", xmlAttributeList.Count);
  584.                         for (int i = 0; i < xmlAttributeList.Count; i++) {
  585.                             InternalST.Soap(this, "ObjectReader.Parse 7");
  586.                             objectReader.Parse((ParseRecord)xmlAttributeList[i]);
  587.                         }
  588.                         xmlAttributeList.Clear();
  589.                     }
  591.                    
  592.                     pr = (ParseRecord)stack.Pop();
  593.                     if ((headerState == HeaderStateEnum.TopLevelObject) && (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)) {
  594.                         // A Base64 array object treated specially by ObjectReader. It is completely processed when
  595.                         // pr.PRparseTypeEnum == InternalParseTypeE.Object, an ObjectEnd is not needed to complete parsing
  596.                         InternalST.Soap(this, "ObjectReader.Parse 3");
  597.                         objectReader.Parse(pr);
  598.                         pr.PRisParsed = true;
  599.                     }
  600.                     else if (pr.PRmemberValueEnum != InternalMemberValueE.Nested) {
  601.                         if ((pr.PRobjectTypeEnum == InternalObjectTypeE.Array) && (pr.PRmemberValueEnum != InternalMemberValueE.Null)) {
  602.                             // Empty array
  603.                             pr.PRmemberValueEnum = InternalMemberValueE.Nested;
  604.                             InternalST.Soap(this, "ObjectReader.Parse 4");
  605.                             objectReader.Parse(pr);
  606.                             pr.PRisParsed = true;
  607.                            
  608.                             pr.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
  609.                         }
  610.                         else if (pr.PRidRef > 0)
  611.                             pr.PRmemberValueEnum = InternalMemberValueE.Reference;
  612.                         else if (pr.PRmemberValueEnum != InternalMemberValueE.Null)
  613.                             pr.PRmemberValueEnum = InternalMemberValueE.InlineValue;
  614.                        
  615.                         switch (headerState) {
  616.                             case HeaderStateEnum.None:
  617.                             case HeaderStateEnum.TopLevelObject:
  618.                                 InternalST.Soap(this, "ObjectReader.Parse 5");
  619.                                 if (pr.PRparseTypeEnum == InternalParseTypeE.Object) {
  620.                                     // Empty object in header case
  621.                                     if (!pr.PRisParsed)
  622.                                         objectReader.Parse(pr);
  623.                                     pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
  624.                                 }
  626.                                 objectReader.Parse(pr);
  627.                                 pr.PRisParsed = true;
  628.                                 break;
  629.                             case HeaderStateEnum.HeaderRecord:
  630.                             case HeaderStateEnum.NestedObject:
  631.                                 ProcessHeaderMember(pr);
  632.                                 break;
  633.                         }
  634.                     }
  635.                     else {
  636.                         // Nested member already parsed, need end to finish nested object
  637.                         pr.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
  638.                         switch (headerState) {
  639.                             case HeaderStateEnum.None:
  640.                             case HeaderStateEnum.TopLevelObject:
  641.                                 InternalST.Soap(this, "ObjectReader.Parse 6");
  642.                                 objectReader.Parse(pr);
  643.                                 pr.PRisParsed = true;
  644.                                 break;
  645.                             case HeaderStateEnum.HeaderRecord:
  646.                             case HeaderStateEnum.NestedObject:
  647.                                 ProcessHeaderMemberEnd(pr);
  648.                                 break;
  649.                         }
  650.                     }
  652.                     PutPr(pr);
  653.                     break;
  654.                 case InternalParseStateE.MemberChild:
  655.                    
  656.                     pr = (ParseRecord)stack.Peek();
  657.                     if (pr.PRmemberValueEnum != InternalMemberValueE.Null)
  658.                         MarshalError("EndElement", (ParseRecord)stack.Peek(), actualName, currentState);
  660.                     break;
  661.                 default:
  662.                    
  663.                     MarshalError("EndElement", (ParseRecord)stack.Peek(), actualName, currentState);
  664.                     break;
  665.             }
  666.             #if _DEBUG
  667.             InternalST.Soap(this, SerTraceString("EndElement End ", (ParseRecord)stack.Peek(), name, currentState, headerState));
  668.             #endif
  669.         }
  670.        
  671.         // Called at the start of processing child nodes for an element
  672.         internal void StartChildren()
  673.         {
  674.             #if _DEBUG
  675.             InternalST.Soap(this, SerTraceString("StartChildren Begin ", (ParseRecord)stack.Peek(), null, currentState, headerState));
  676.             #endif
  677.             ParseRecord pr = null;
  678.            
  679.             switch (currentState) {
  680.                 case InternalParseStateE.Object:
  681.                     InternalST.Soap(this, "StartChildren Object");
  682.                     pr = (ParseRecord)stack.Peek();
  683.                     ParseRecord objectPr = (ParseRecord)stack.PeekPeek();
  684.                     ProcessAttributes(pr, objectPr);
  685.                     if (pr.PRarrayTypeEnum != InternalArrayTypeE.Base64) {
  686.                         if (!((pr.PRparseTypeEnum == InternalParseTypeE.Envelope) || (pr.PRparseTypeEnum == InternalParseTypeE.Body))) {
  687.                             currentState = InternalParseStateE.Member;
  688.                            
  689.                         }
  690.                        
  691.                         switch (headerState) {
  692.                             case HeaderStateEnum.None:
  693.                             case HeaderStateEnum.TopLevelObject:
  694.                                 InternalST.Soap(this, "ObjectReader.Parse 8");
  695.                                 InternalST.Soap(this, "SoapParser.StartChildren TopFound " + isTopFound + " objectPr.parseTypeEnum " + (objectPr == null ? "null" : ((Enum)objectPr.PRparseTypeEnum).ToString()));
  696.                                 if (!isTopFound && (objectPr != null) && (objectPr.PRparseTypeEnum == InternalParseTypeE.Body)) {
  697.                                     pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
  698.                                     isTopFound = true;
  699.                                     InternalST.Soap(this, "SoapParser.StartChildren change position to top");
  700.                                 }
  702.                                 objectReader.Parse(pr);
  703.                                 pr.PRisParsed = true;
  704.                                 break;
  705.                             case HeaderStateEnum.HeaderRecord:
  706.                             case HeaderStateEnum.NestedObject:
  707.                             case HeaderStateEnum.FirstHeaderRecord:
  708.                                 ProcessHeader(pr);
  709.                                 break;
  710.                         }
  711.                     }
  713.                     break;
  714.                 case InternalParseStateE.Member:
  715.                    
  716.                     InternalST.Soap(this, "StartChildren Member");
  717.                     pr = (ParseRecord)stack.Peek();
  718.                     currentState = InternalParseStateE.MemberChild;
  719.                     break;
  720.                 case InternalParseStateE.MemberChild:
  721.                 default:
  722.                    
  723.                     MarshalError("StartChildren", (ParseRecord)stack.Peek(), null, currentState);
  724.                     break;
  725.             }
  726.            
  727.             #if _DEBUG
  728.             InternalST.Soap(this, "StartChildren 10");
  729.             InternalST.Soap(this, SerTraceString("StartChildren End ", (ParseRecord)stack.Peek(), null, currentState, headerState));
  730.             #endif
  731.         }
  732.        
  733.         // Called at the end of process the child nodes for an element
  734.         internal void FinishChildren(string prefix, string name, string urn)
  735.         {
  736.             #if _DEBUG
  737.             InternalST.Soap(this, SerTraceString("FinishChildren Begin ", (ParseRecord)stack.Peek(), name, prefix, urn, currentState, headerState));
  738.             #endif
  739.             ParseRecord pr = null;
  740.            
  741.             switch (currentState) {
  742.                 case InternalParseStateE.Member:
  743.                     pr = (ParseRecord)stack.Peek();
  744.                     currentState = pr.PRparseStateEnum;
  745.                     // For an object which has a value such as top level System.String
  746.                     pr.PRvalue = textValue;
  747.                     textValue = "";
  748.                     break;
  749.                 case InternalParseStateE.MemberChild:
  750.                    
  751.                     pr = (ParseRecord)stack.Peek();
  752.                     currentState = pr.PRparseStateEnum;
  753.                    
  754.                     ParseRecord objectPr = (ParseRecord)stack.PeekPeek();
  755.                     pr.PRvalue = textValue;
  756.                     // Non-primitive type need to filter
  757.                     textValue = "";
  758.                    
  759.                     break;
  760.                 case InternalParseStateE.Object:
  761.                    
  762.                     pr = (ParseRecord)stack.Peek();
  763.                     if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64) {
  764.                         pr.PRvalue = textValue;
  765.                         textValue = "";
  766.                     }
  768.                     // Only occur for top obj