SoapParser

1. // ==++==
2. // 
3. //   
4. //    Copyright (c) 2002 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;
40.     sealed internal 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;
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.WhitespaceHandling = WhitespaceHandling.Significant; 
59.         xmlReader.XmlResolver= null;
60.             soapHandler = new SoapHandler(this);
61.         }
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.         }
77.         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.         }
88.         // Start parsing the input
89.         public void Run()
90.         {
91.             InternalST.Soap( this, "Run");     
92.             try
93.             {
94.                 soapHandler.Start(xmlReader);
95.                 ParseXml();
96.                 soapHandler.Finish();
97.             }
98.             catch (EndOfStreamException)
99.             {
100.             }
101.         }
103.         internal void Stop()
104.         {
105.             InternalST.Soap( this, "Stop");     
106.             bStop = true;
107.         }
110.         private void ParseXml()
111.         {
112.             InternalST.Soap( this, "ParseXml");     
113.             while (!bStop && xmlReader.Read())
114.             {
115.                 if (depth < xmlReader.Depth)
116.                 {
117.                     soapHandler.StartChildren();
118.                     depth = xmlReader.Depth;
119.                 }
120.                 else if (depth > xmlReader.Depth)
121.                 {
122.                     soapHandler.FinishChildren(xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI);
123.                     depth = xmlReader.Depth;
124.                 }
126.                 switch (xmlReader.NodeType)
127.                 {
128.                     case(XmlNodeType.None):
129.                         break;
130.                     case(XmlNodeType.Element):
131.                         Dump("Node Element", xmlReader);                   
132.                         soapHandler.StartElement(xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI);
133.                         int attributeCount = xmlReader.AttributeCount;
134.                         while (xmlReader.MoveToNextAttribute())
135.                         {
136.                             soapHandler.Attribute(xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI, xmlReader.Value);
137.                         }
138.                         xmlReader.MoveToElement();
139.                         if (xmlReader.IsEmptyElement)
140.                             soapHandler.EndElement(xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI);
141.                         break;                  
142.                     case XmlNodeType.EndElement:
143.                         Dump("Node EndElement", xmlReader);                   
144.                         soapHandler.EndElement(xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI);
145.                         break;
146.                     case(XmlNodeType.Text):
147.                         Dump("Node Text", xmlReader);                   
148.                         soapHandler.Text(xmlReader.Value);
149.                         break;                  
150.                     case(XmlNodeType.SignificantWhitespace):
151.                         Dump("Node SignificantWhitespace", xmlReader);                   
152.                         break;                  
153.                     case(XmlNodeType.Entity):
154.                         Dump("Node Entity", xmlReader);                   
155.                         break;                  
156.                     case(XmlNodeType.CDATA):
157.                         Dump("Node CDATA", xmlReader);                   
158.                         soapHandler.Text(xmlReader.Value);
159.                         break;                  
160.                     case(XmlNodeType.Comment):
161.                         Dump("Node Comment", xmlReader);                   
162.                         soapHandler.Comment(xmlReader.Value);                        
163.                         break;                  
164.                     case(XmlNodeType.EntityReference):
165.                         Dump("Node EntityReference", xmlReader);                    
166.                         break;                  
167.                     case(XmlNodeType.ProcessingInstruction):
168.                         Dump("Node ProcessingInstruction", xmlReader);                  
169.                         break;                  
170.                     case(XmlNodeType.Document):
171.                         Dump("Node Document", xmlReader);                   
172.                         break;                  
173.                     case(XmlNodeType.DocumentType):
174.                         Dump("Node DocumentType", xmlReader);                   
175.                         break;                  
176.                     case(XmlNodeType.DocumentFragment):
177.                         Dump("Node DocumentFragment", xmlReader);                   
178.                         break;                  
179.                     case(XmlNodeType.Notation):
180.                         Dump("Node Notation", xmlReader);                   
181.                         break;                  
182.                     case(XmlNodeType.Whitespace):
183.                         Dump("Node Whitespace", xmlReader);                   
184.                         break;                  
185.                     case(XmlNodeType.EndEntity):
186.                         Dump("Node EndEntity", xmlReader);                  
187.                         break;                  
188.                     default:
189.                         Dump("Node Default", xmlReader);                    
190.                         break;                  
191.                 }
193.             }
194.         }
196.         [System.Diagnostics.Conditional("SER_LOGGING")]
197.         private static void Dump(String name, XmlReader xmlReader)
198.         {
199.             InternalST.Soap("========== "+name+" ============");
200.             InternalST.Soap("Prefix               : " + xmlReader.Prefix);
201.             InternalST.Soap("Name                 : " + xmlReader.Name);
202.             InternalST.Soap("LocalName            : " + xmlReader.LocalName);
203.             InternalST.Soap("Namespace            : " + xmlReader.NamespaceURI);
204.             InternalST.Soap("Depth                : " + xmlReader.Depth);
205.             InternalST.Soap("Value                : [" + xmlReader.Value+"]");
206.             InternalST.Soap("IsDefault            : " + xmlReader.IsDefault);
207.             InternalST.Soap("XmlSpace             : " + xmlReader.XmlSpace);
208.             InternalST.Soap("XmlLang              : " + xmlReader.XmlLang);
209.             InternalST.Soap("QuoteChar            : " + xmlReader.QuoteChar);
210.             InternalST.Soap("================================/n");            
211.         }
213.     }
215.     // Sets the handler which contains the callbacks for the parser
216.     sealed internal class SoapHandler
217.     {
218.         SerStack stack= new SerStack("SoapParser Stack");
220.         XmlTextReader xmlTextReader = null;
221.         SoapParser soapParser = null;
224.         // Current text
225.         String textValue = "";
227.         // XML Formatter
228.         ObjectReader objectReader;
229.         internal Hashtable keyToNamespaceTable; //needed for xsd QName type
231.         // Current state
232.         InternalParseStateE currentState;
233.         bool isEnvelope = false;
234.         bool isBody = false;
235.         bool isTopFound = false;
236.         HeaderStateEnum headerState = HeaderStateEnum.None;
238.         // Attribute holder
239.         SerStack attributeValues = new SerStack("AttributePrefix");
241.         SerStack prPool = new SerStack("prPool");
243.         // XML Key to AssemblyId table
244.         // Key of SOAP has an AssemblyId of -1
245.         // Key of urt has an AssemblyId of -2
246.         Hashtable assemKeyToAssemblyTable = null;
247.         Hashtable assemKeyToNameSpaceTable = null;
248.         Hashtable assemKeyToInteropAssemblyTable = null;
249.         Hashtable nameSpaceToKey = null; // Used to assign a key to default xml namespaces
250.         String soapKey = "SOAP-ENC"; //xml key for soap, should be SOAP
251.         String urtKey = "urt"; //xml key for urt, should be urt
252.         String soapEnvKey = "SOAP-ENV"; //xml key for SOAPRENV, initial value, might change
253.         String xsiKey = "xsi"; //xml key for xsi, initial value, might change
254.         String xsdKey = "xsd"; //xml key for xsd, initial value, might change
255.         int nextPrefix = 0; // Used to generate a prefix if necessary
257.         internal SoapHandler(SoapParser soapParser)
258.         {
259.             this.soapParser = soapParser;
260.         }
262.         internal void Init(ObjectReader objectReader)
263.         {
264.             this.objectReader = objectReader;
265.             objectReader.soapHandler = this;
266.             isEnvelope = false;
267.             isBody = false;
268.             isTopFound = false;
269.             attributeValues.Clear();
270.             assemKeyToAssemblyTable = new Hashtable(10);
271.             assemKeyToAssemblyTable[urtKey] = new SoapAssemblyInfo(SoapUtil.urtAssemblyString, SoapUtil.urtAssembly);
272.             assemKeyToNameSpaceTable = new Hashtable(10);
273.             assemKeyToInteropAssemblyTable = new Hashtable(10);
274.             nameSpaceToKey = new Hashtable(5);
275.             keyToNamespaceTable = new Hashtable(10);
277.         }
279.         private String NextPrefix()
280.         {
281.             nextPrefix++;
282.             return "_P"+nextPrefix;
284.         }
286.         internal class AttributeValueEntry
287.         {
288.             internal String prefix;
289.             internal String key;
290.             internal String value;
291.             internal String urn;
293.             internal AttributeValueEntry(String prefix, String key, String value, String urn)
294.             {
295.                 this.prefix = prefix;
296.                 this.key = key;
297.                 this.value = value;
298.                 this.urn = urn;
299.             }
300.         }
302.         private ParseRecord GetPr()
303.         {
304.             ParseRecord pr = null;
306.             if (!prPool.IsEmpty())
307.             {
308.                 pr = (ParseRecord)prPool.Pop();
309.                 pr.Init();
310.             }
311.             else
312.                 pr = new ParseRecord();
314.             return pr;
315.         }
317.         private void PutPr(ParseRecord pr)
318.         {
319.             prPool.Push(pr);
320.         }
322.         // Creates a trace string
323.         private static String SerTraceString(String handler, ParseRecord pr, String value, InternalParseStateE currentState, HeaderStateEnum headerState)
324.         {               
325.             String valueString = "";
326.             if (value != null)
327.                 valueString = value;
329.             String prString = "";
330.             if (pr != null)
331.                 prString = ((Enum)pr.PRparseStateEnum).ToString();
333.             return handler+" - "+valueString+", State "+((Enum)currentState).ToString()+", PushState "+prString;        
334.         }
336.         private static String SerTraceString(String handler, ParseRecord pr, String value, String prefix, String urn, InternalParseStateE currentState, HeaderStateEnum headerState)
337.         {
338.             String valueString = "";
339.             if (value != null)
340.                 valueString = value;
342.             String prString = "";
343.             if (pr != null)
344.                 prString = ((Enum)pr.PRparseStateEnum).ToString();
346.             return handler+" - name "+valueString+", prefix "+prefix+", urn "+urn+", CuurentState "+((Enum)currentState).ToString()+", HeaderState "+((Enum)headerState).ToString()+", PushState "+prString;        
347.         }
351.         // Formats the error message and throws a SerializationException
352.         private void MarshalError(String handler, ParseRecord pr, String value, InternalParseStateE currentState)
353.         {
354.             String traceString = SerTraceString(handler, pr, value, currentState, headerState);
356.             InternalST.Soap( this,"MarshalError,",traceString);
358.             throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_Syntax"),traceString));                                                    
359.         }
361.         // Throws a SerializationException
362.         private void MarshalError(String message)
363.         {
364.             InternalST.Soap( this,"MarshalError, ",message);
366.             throw new SerializationException(message);
367.         }
370.         // Called at the beginning of parsing
371.         internal void Start(XmlTextReader p)
372.         {
373.             InternalST.Soap( this,"Start ");
374.             currentState = InternalParseStateE.Object;
375.             xmlTextReader = p;
376.         }
378.         // Called at the end of parsing
379.         internal void Finish()
380.         {
381.         }
384.         // Called when a parse error occurs
385.         internal void Error(Exception ex)
386.         {
387.             if (ex != null)
388.             {
389.                 InternalST.Soap( this,"Soap Parser Error: ",ex);
390.                 InternalST.Soap( ex.StackTrace);
391.             }
393.             if (!(ex is EndOfStreamException))
394.             {
395.                 if (ex is ServerException || ex is System.Security.SecurityException)
396.                     throw ex;
397.                 else
398.                     throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_Parser"),ex));                                                                 
399.             }
400.         }
402.         // Called at the begining of an element
403.         internal void StartElement(String prefix, String name, String urn)
404.         {
405.             InternalST.Soap( this,SerTraceString("StartElement Begin ", (ParseRecord)stack.Peek(), name, prefix, urn, currentState, headerState));
406.             //InternalST.Soap( this,"prefix ",prefix,", Name ",name,", urn ",urn);
408.             String actualName = NameFilter(name);
409.             String actualPrefix = prefix;
411.             ParseRecord pr = null;
413.             if (!((urn == null) || (urn.Length == 0)) && ((prefix == null) || (prefix.Length == 0)))
414.             {
415.                 // Need to assign a prefix to the urn
416.                 if (nameSpaceToKey.ContainsKey(urn))
417.                     actualPrefix = (String)nameSpaceToKey[urn];
418.                 else
419.                 {
420.                     actualPrefix = NextPrefix();
421.                     nameSpaceToKey[urn] = actualPrefix;
422.                 }
423.                 InternalST.Soap( this,"StartElement Begin null urn assigned prefix ", actualPrefix);
424.             }
427.             switch (currentState)
428.             {
429.                 case InternalParseStateE.Object:
430.                     pr = GetPr();
431.                     pr.PRname = actualName;
432.                     pr.PRnameXmlKey = actualPrefix;
433.                     pr.PRxmlNameSpace = urn;
434.                     pr.PRparseStateEnum = InternalParseStateE.Object;
436.                     if ((String.Compare(name, "Array", true , CultureInfo.InvariantCulture) == 0) && actualPrefix.Equals(soapKey))
437.                         pr.PRparseTypeEnum = InternalParseTypeE.Object;
438.                     else if (((String.Compare(name, "anyType", true, CultureInfo.InvariantCulture) == 0) || (String.Compare(name, "ur-type", true , CultureInfo.InvariantCulture) == 0)) && actualPrefix.Equals(xsdKey))
439.                     {
440.                         pr.PRname = "System.Object";
441.                         pr.PRnameXmlKey = urtKey;
442.                         pr.PRxmlNameSpace = urn;                        
443.                         pr.PRparseTypeEnum = InternalParseTypeE.Object;
444.                     }
445.                     else if (String.Compare(urn, "http://schemas.xmlsoap.org/soap/envelope/", true, CultureInfo.InvariantCulture) == 0)
446.                     {
447.                         if (String.Compare(name, "Envelope", true, CultureInfo.InvariantCulture) == 0)
448.                         {
449.                             if (isEnvelope)
450.                                 throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_Parser_Envelope"),prefix+":"+name));
452.                             isEnvelope = true;
453.                             pr.PRparseTypeEnum = InternalParseTypeE.Envelope;
454.                         }
455.                         else if (String.Compare(name, "Body", true, CultureInfo.InvariantCulture) == 0)
456.                         {
457.                             if (!isEnvelope)
458.                                 throw new SerializationException(SoapUtil.GetResourceString("Serialization_Parser_BodyChild"));
460.                             if (isBody)
461.                                 throw new SerializationException(SoapUtil.GetResourceString("Serialization_Parser_BodyOnce"));
463.                             isBody = true;
464.                             headerState = HeaderStateEnum.None;
465.                             isTopFound = false;
466.                             pr.PRparseTypeEnum = InternalParseTypeE.Body;                           
467.                         }
468.                         else if (String.Compare(name, "Header", true, CultureInfo.InvariantCulture) == 0)
469.                         {
470.                             if (!isEnvelope)
471.                                 throw new SerializationException(SoapUtil.GetResourceString("Serialization_Parser_Header"));
473.                             pr.PRparseTypeEnum = InternalParseTypeE.Headers;
474.                             headerState = HeaderStateEnum.FirstHeaderRecord;
475.                         }
476.                         else
477.                             pr.PRparseTypeEnum = InternalParseTypeE.Object; //SoapFault has an envelope key                    
478.                     }
479.                     else
480.                     {
481.                         pr.PRparseTypeEnum = InternalParseTypeE.Object;
482.                     }
484.                     stack.Push(pr);
485.                     break;
487.                 case InternalParseStateE.Member:
488.                     pr = GetPr();
490.                     // Members of Top object records cannot be reused because of the need to resolving fake element
491.                     ParseRecord objectPr = (ParseRecord)stack.Peek();
492.                     pr.PRname = actualName;
493.                     pr.PRnameXmlKey = actualPrefix;
494.                     pr.PRxmlNameSpace = urn;                    
495.                     pr.PRparseTypeEnum = InternalParseTypeE.Member;
496.                     pr.PRparseStateEnum = InternalParseStateE.Member;
497.                     stack.Push(pr);
498.                     break;
500.                 case InternalParseStateE.MemberChild:
501.                     objectPr = (ParseRecord)stack.PeekPeek();                   
502.                     pr = (ParseRecord)stack.Peek();
503.                     pr.PRmemberValueEnum = InternalMemberValueE.Nested;
504.                     ProcessAttributes(pr, objectPr);
505.                     switch (headerState)
506.                     {
507.                         case HeaderStateEnum.None:
508.                         case HeaderStateEnum.TopLevelObject:
509.                             InternalST.Soap( this,"ObjectReader.Parse 1");
510.                             objectReader.Parse(pr);
511.                             pr.PRisParsed = true;
512.                             break;
513.                         case HeaderStateEnum.HeaderRecord:
514.                         case HeaderStateEnum.NestedObject:                          
515.                             ProcessHeaderMember(pr);
516.                             break;
517.                     }
519.                     ParseRecord nestPr = GetPr();
520.                     nestPr.PRparseTypeEnum = InternalParseTypeE.Member;
521.                     nestPr.PRparseStateEnum = InternalParseStateE.Member;
522.                     nestPr.PRname = actualName;
523.                     nestPr.PRnameXmlKey = actualPrefix;
524.                     pr.PRxmlNameSpace = urn;                    
525.                     currentState = InternalParseStateE.Member;
526.                     stack.Push(nestPr);
527.                     break;
529.                 default:
530.                     MarshalError("StartElement", (ParseRecord)stack.Peek(), actualName, currentState);
531.                     break;
532.             }
534.             InternalST.Soap( this,SerTraceString("StartElement End ", (ParseRecord)stack.Peek(), name, currentState, headerState));
535.         }
538.         // Called at the end of an element
539.         internal void  EndElement(String prefix, String name, String urn)
540.         {
541.             InternalST.Soap( this,SerTraceString("EndElement Begin ", (ParseRecord)stack.Peek(), name, prefix, urn, currentState, headerState));
542.             //InternalST.Soap( this,"prefix ",prefix,", Name ",name,", urn ",urn);
544.             String actualName = NameFilter(name);
546.             ParseRecord objectPr = null;
547.             ParseRecord pr = null;
549.             switch (currentState)
550.             {
551.                 case InternalParseStateE.Object:
552.                     pr = (ParseRecord)stack.Pop();
553.                     if (pr.PRparseTypeEnum == InternalParseTypeE.Envelope)
554.                         pr.PRparseTypeEnum = InternalParseTypeE.EnvelopeEnd;
555.                     else if (pr.PRparseTypeEnum == InternalParseTypeE.Body)
556.                         pr.PRparseTypeEnum = InternalParseTypeE.BodyEnd;
557.                     else if (pr.PRparseTypeEnum == InternalParseTypeE.Headers)
558.                     {
559.                         pr.PRparseTypeEnum = InternalParseTypeE.HeadersEnd;
560.                         headerState = HeaderStateEnum.HeaderRecord;
561.                     }
562.                     else if (pr.PRarrayTypeEnum != InternalArrayTypeE.Base64)
563.                     {
564.                         // A Base64 array object treated special by ObjectReader. It is completely processed when
565.                         // pr.PRparseTypeEnum == InternalParseTypeE.Object, an ObjectEnd is not needed to complete parsing
567.                         // For an element like <element />, the check was not made for top
568.                         objectPr = (ParseRecord)stack.Peek();
569.                         InternalST.Soap( this,"SoapParser.EndElement TopFound "+isTopFound+" objectPr.parseTypeEnum "+(objectPr == null?"null":((Enum)objectPr.PRparseTypeEnum).ToString()));
570.                         if (!isTopFound && (objectPr != null ) && (objectPr.PRparseTypeEnum == InternalParseTypeE.Body))
571.                         {
572.                             pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
573.                             isTopFound = true;
574.                             InternalST.Soap( this,"SoapParser.EndElement change position to top");
575.                         }
577.                         if (!pr.PRisParsed)
578.                         {
579.                             InternalST.Soap( this,"SoapParser.EndElement Object hasn't been parsed");
580.                             if (!pr.PRisProcessAttributes && !(pr.PRobjectPositionEnum == InternalObjectPositionE.Top && objectReader.IsFakeTopObject))
581.                                 ProcessAttributes(pr, objectPr);
582.                             objectReader.Parse(pr);
583.                             pr.PRisParsed = true;                           
584.                         }
585.                         pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;                                              
586.                     }
588.                     switch (headerState)
589.                     {
590.                         case HeaderStateEnum.None:
591.                         case HeaderStateEnum.TopLevelObject:
592.                             InternalST.Soap( this,"SoapParser.EndElement Parse EndObject");                 
593.                             objectReader.Parse(pr);
594.                             break;
595.                         case HeaderStateEnum.HeaderRecord:
596.                         case HeaderStateEnum.NestedObject:
597.                             InternalST.Soap( this,"SoapParser.EndElement ProcessHeaderEnd");                                                                            
598.                             ProcessHeaderEnd(pr);
599.                             break;
600.                     }
602.                     if (pr.PRparseTypeEnum == InternalParseTypeE.EnvelopeEnd)
603.                     {
604.                         // End of document
605.                         soapParser.Stop();
606.                     }
608.                     PutPr(pr);
609.                     break;
611.                 case InternalParseStateE.Member:
612.                     pr = (ParseRecord)stack.Peek();
613.                     objectPr = (ParseRecord)stack.PeekPeek();
614.                     ProcessAttributes(pr, objectPr);
616.                     // Check if there are any XmlAttribute records, if there are, process them
617.                     if (xmlAttributeList != null)
618.                         InternalST.Soap( this,"XmlAttribute check count ", xmlAttributeList.Count);
619.                     else
620.                         InternalST.Soap( this,"XmlAttribute null");
622.                     if ((xmlAttributeList != null) && (xmlAttributeList.Count > 0))
623.                     {
624.                         InternalST.Soap( this,"xmlAttribute list count ", xmlAttributeList.Count);
625.                         for (int i=0; i<xmlAttributeList.Count; i++)
626.                         {
627.                             InternalST.Soap( this,"ObjectReader.Parse 7");                                  
628.                             objectReader.Parse((ParseRecord)xmlAttributeList[i]);
629.                         }
630.                         xmlAttributeList.Clear();
631.                     }
633.                     pr = (ParseRecord)stack.Pop();
634.                     if ((headerState == HeaderStateEnum.TopLevelObject) && (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64))
635.                     {
636.                         // A Base64 array object treated specially by ObjectReader. It is completely processed when
637.                         // pr.PRparseTypeEnum == InternalParseTypeE.Object, an ObjectEnd is not needed to complete parsing
638.                         InternalST.Soap( this,"ObjectReader.Parse 3");                      
639.                         objectReader.Parse(pr);
640.                         pr.PRisParsed = true;                       
641.                     }
642.                     else if (pr.PRmemberValueEnum != InternalMemberValueE.Nested)
643.                     {
644.                         if ((pr.PRobjectTypeEnum == InternalObjectTypeE.Array) && (pr.PRmemberValueEnum != InternalMemberValueE.Null))
645.                         {
646.                             // Empty array
647.                             pr.PRmemberValueEnum = InternalMemberValueE.Nested;
648.                             InternalST.Soap( this,"ObjectReader.Parse 4");                          
649.                             objectReader.Parse(pr);
650.                             pr.PRisParsed = true;                           
652.                             pr.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
653.                         }
654.                         else if (pr.PRidRef > 0)
655.                             pr.PRmemberValueEnum = InternalMemberValueE.Reference;
656.                         else if (pr.PRmemberValueEnum != InternalMemberValueE.Null)
657.                             pr.PRmemberValueEnum = InternalMemberValueE.InlineValue;
659.                         switch (headerState)
660.                         {
661.                             case HeaderStateEnum.None:
662.                             case HeaderStateEnum.TopLevelObject:
663.                                 InternalST.Soap( this,"ObjectReader.Parse 5"); 
664.                                 if (pr.PRparseTypeEnum == InternalParseTypeE.Object)
665.                                 {
666.                                     // Empty object in header case
667.                                     if (!pr.PRisParsed)
668.                                         objectReader.Parse(pr);
669.                                     pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
670.                                 }
671.                                 objectReader.Parse(pr);
672.                                 pr.PRisParsed = true;                               
673.                                 break;
674.                             case HeaderStateEnum.HeaderRecord:
675.                             case HeaderStateEnum.NestedObject:                              
676.                                 ProcessHeaderMember(pr);
677.                                 break;
678.                         }
679.                     }
680.                     else
681.                     {
682.                         // Nested member already parsed, need end to finish nested object
683.                         pr.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
684.                         switch (headerState)
685.                         {
686.                             case HeaderStateEnum.None:
687.                             case HeaderStateEnum.TopLevelObject:
688.                                 InternalST.Soap( this,"ObjectReader.Parse 6");                              
689.                                 objectReader.Parse(pr);
690.                                 pr.PRisParsed = true;                               
691.                                 break;
692.                             case HeaderStateEnum.HeaderRecord:
693.                             case HeaderStateEnum.NestedObject:                              
694.                                 ProcessHeaderMemberEnd(pr);
695.                                 break;
696.                         }
697.                     }
698.                     PutPr(pr);
699.                     break;
701.                 case InternalParseStateE.MemberChild:
702.                     pr = (ParseRecord)stack.Peek();
703.                     if (pr.PRmemberValueEnum != InternalMemberValueE.Null)
704.                         MarshalError("EndElement", (ParseRecord)stack.Peek(), actualName, currentState);
705.                     break;
707.                 default:
708.                     MarshalError("EndElement", (ParseRecord)stack.Peek(), actualName, currentState);
709.                     break;
710.             }
711.             InternalST.Soap( this,SerTraceString("EndElement End ", (ParseRecord)stack.Peek(), name, currentState, headerState));
712.         }
714.         // Called at the start of processing child nodes for an element
715.         internal void StartChildren()
716.         {
717.             InternalST.Soap( this,SerTraceString("StartChildren Begin ", (ParseRecord)stack.Peek(), null, currentState, headerState));
719.             ParseRecord pr = null;
721.             switch (currentState)
722.             {
723.                 case InternalParseStateE.Object:
724.                     InternalST.Soap( this,"StartChildren Object");
725.                     pr = (ParseRecord)stack.Peek();
726.                     ParseRecord objectPr = (ParseRecord)stack.PeekPeek();
727.                     ProcessAttributes(pr, objectPr);
728.                     if (pr.PRarrayTypeEnum != InternalArrayTypeE.Base64)
729.                     {
730.                         if (!((pr.PRparseTypeEnum == InternalParseTypeE.Envelope) || (pr.PRparseTypeEnum == InternalParseTypeE.Body)))
731.                         {
732.                             currentState = InternalParseStateE.Member;
734.                         }
736.                         switch (headerState)
737.                         {
738.                             case HeaderStateEnum.None:
739.                             case HeaderStateEnum.TopLevelObject:
740.                                 InternalST.Soap( this,"ObjectReader.Parse 8");
741.                                 InternalST.Soap( this,"SoapParser.StartChildren TopFound "+isTopFound+" objectPr.parseTypeEnum "+(objectPr == null?"null":((Enum)objectPr.PRparseTypeEnum).ToString()));
742.                                 if (!isTopFound && (objectPr != null ) && (objectPr.PRparseTypeEnum == InternalParseTypeE.Body))
743.                                 {
744.                                     pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
745.                                     isTopFound = true;
746.                                     InternalST.Soap( this,"SoapParser.StartChildren change position to top");
747.                                 }
748.                                 objectReader.Parse(pr);
749.                                 pr.PRisParsed = true;                               
750.                                 break;
751.                             case HeaderStateEnum.HeaderRecord:
752.                             case HeaderStateEnum.NestedObject:
753.                             case HeaderStateEnum.FirstHeaderRecord:
754.                                 ProcessHeader(pr);                              
755.                                 break;                          
756.                         }
757.                     }
758.                     break;
760.                 case InternalParseStateE.Member:
761.                     InternalST.Soap( this,"StartChildren Member");                  
762.                     pr = (ParseRecord)stack.Peek();             
763.                     currentState = InternalParseStateE.MemberChild;
764.                     break;
766.                 case InternalParseStateE.MemberChild:
767.                 default:
768.                     MarshalError("StartChildren", (ParseRecord)stack.Peek(), null, currentState);
769.                     break;
770.             }
772.             InternalST.Soap( this, "StartChildren 10");     
773.             InternalST.Soap( this,SerTraceString("StartChildren End ", (ParseRecord)stack.Peek(), null, currentState, headerState));
774.         }
776.         // Called at the end of process the child nodes for an element
777.         internal void FinishChildren(String prefix, String name, String urn)
778.         {
779.             InternalST.Soap( this,SerTraceString("FinishChildren Begin ", (ParseRecord)stack.Peek(), name, prefix, urn, currentState, headerState));
780.             //InternalST.Soap( this,"prefix ",prefix,", Name ",name,", urn ",urn);
782.             ParseRecord pr = null;
784.             switch (currentState)
785.             {
786.                 case InternalParseStateE.Member:
787.                     pr = (ParseRecord)stack.Peek();                             
788.                     currentState = pr.PRparseStateEnum;
789.                     // For an object which has a value such as top level System.String
790.                     pr.PRvalue = textValue;
791.                     textValue = "";
792.                     break;
794.                 case InternalParseStateE.MemberChild:
795.                     pr = (ParseRecord)stack.Peek();                             
796.                     currentState = pr.PRparseStateEnum;
798.                     ParseRecord objectPr = (ParseRecord)stack.PeekPeek();
799.                     pr.PRvalue = textValue; // Non-primitive type need to filter
800.                     textValue = "";
802.                     break;
804.                 case InternalParseStateE.Object:
805.                     pr = (ParseRecord)stack.Peek();
806.                     if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
807.                     {
808.                         pr.PRvalue = textValue;
809.                         textValue = "";
810.                     }
811.                     // Only occur for top object, returning to SerializedStreamHeader object
812.                     break;
814.                 default:
815.                     MarshalError("FinishChildren", (ParseRecord)stack.Peek(), name, currentState);
816.                     break;
817.             }
819.             InternalST.Soap( this,SerTraceString("FinishChildren End ", (ParseRecord)stack.Peek(), name, currentState, headerState));
820.         }
822.         // Called at when an attribute is finished
823.         internal void Attribute(String prefix, String name, String urn, String value)
824.         {
825.             InternalST.Soap( this,SerTraceString("Attribute Begin ", (ParseRecord)stack.Peek(), name, prefix, urn, currentState, headerState));
826.             InternalST.Soap( this,"Attribute prefix ",prefix,", Name ",name,", urn ",urn, ",value "+value);
828.             switch (currentState)
829.             {
830.                 case InternalParseStateE.Object:
831.                 case InternalParseStateE.Member:
833.                     ParseRecord pr = (ParseRecord)stack.Peek();
835.                     String actualName = name;
836.                     if (!((urn == null) || (urn.Length == 0)) && ((prefix == null) || (prefix.Length == 0)))
837.                     {
838.                         // Default namespaces, assign a name to reference urn
839.                         if (nameSpaceToKey.ContainsKey(urn))
840.                             actualName = (String)nameSpaceToKey[urn];
841.                         else
842.                         {
843.                             actualName = NextPrefix();
844.                             nameSpaceToKey[urn] = actualName;
845.                         }
846.                         InternalST.Soap( this,"EndAttribute null urn assigned Name ", actualName);                      
847.                     }
849.                     if (!((prefix == null) || (actualName == null) ||(value == null)|| (urn == null)))
850.                     {
851.                         //  Xml parser returns an end attribute without a begin attribute for xmlns="" (which is a cancellation of a default namespace)
852.                         // In this case want to avoid the push
853.                         attributeValues.Push(new AttributeValueEntry(prefix, actualName, value, urn));
854.                     }
855.                     break;
856.                 case InternalParseStateE.MemberChild:
857.                 default:
858.                     MarshalError("EndAttribute, Unknown State ", (ParseRecord)stack.Peek(), name, currentState);
859.                     break;
860.             }
862.             InternalST.Soap( this,SerTraceString("EndAttribute End ", (ParseRecord)stack.Peek(), name, currentState, headerState));
863.         }
866.         // Called at when a text element is encountered
867.         internal void Text(String text)
868.         {
869.             InternalST.Soap( this,"Text ",text);
870.             textValue = text;
871.         }
873.         // Called at when a Comment is encountered (not used)
874.         internal void Comment(String body)
875.         {
876.             InternalST.Soap( this,"Comment ",body);                     
877.         }
880.         // Process the attributes placed into the ParseRecord
881.         StringBuilder sburi = new StringBuilder(50);
882.         private void ProcessAttributes(ParseRecord pr, ParseRecord objectPr)
883.         {
884.             InternalST.Soap( this, "ProcessAttributes Entry ",pr.Trace()," headerState ",((Enum)headerState).ToString());
885.             String keyPosition = null;
886.             String keyOffset = null;
887.             String keyMustUnderstand = null;
889.             pr.PRisProcessAttributes = true;
891.             String SoapKeyUrl = "http://schemas.xmlsoap.org/soap/encoding/";
892.             int SoapKeyUrlLength = SoapKeyUrl.Length;
893.             String UrtKeyUrl = "http://schemas.microsoft.com/clr/id";
894.             int UrtKeyUrlLength = UrtKeyUrl.Length;
895.             String SoapEnvKeyUrl = "http://schemas.xmlsoap.org/soap/envelope/";
896.             int SoapEnvKeyUrlLength = SoapEnvKeyUrl.Length;
897.             String XSIKey2001 = "http://www.w3.org/2001/XMLSchema-instance";
898.             int XSIKey2001Length = XSIKey2001.Length;
899.             String XSIKey2000 = "http://www.w3.org/2000/10/XMLSchema-instance";
900.             int XSIKey2000Length = XSIKey2000.Length;
901.             String XSIKey1999 = "http://www.w3.org/1999/XMLSchema-instance";
902.             int XSIKey1999Length = XSIKey1999.Length;
904.             String XSDKey1999 = "http://www.w3.org/1999/XMLSchema";
905.             int XSDKey1999Length = XSDKey1999.Length;
906.             String XSDKey2000 = "http://www.w3.org/2000/10/XMLSchema";
907.             int XSDKey2000Length = XSDKey2000.Length;
908.             String XSDKey2001 = "http://www.w3.org/2001/XMLSchema";
909.             int XSDKey2001Length = XSDKey2001.Length;
910.             String clrNS = "http://schemas.microsoft.com/soap/encoding/clr/1.0";
911.             int clrNSLength = clrNS.Length;
913.             for (int i = 0; i<attributeValues.Count(); i++)
914.             {
915.                 AttributeValueEntry attributeValueEntry = (AttributeValueEntry)attributeValues.GetItem(i);
916.                 String prefix = attributeValueEntry.prefix;
917.                 String key = attributeValueEntry.key;
918.                 if ((key == null) || (key.Length == 0))
919.                     key = pr.PRnameXmlKey; //case where there is a default key
920.                 String value = attributeValueEntry.value;
921.                 bool prefixMatchesXmlns = false;
922.                 String urn = attributeValueEntry.urn;
923.                 InternalST.Soap( this, "ProcessAttributes attribute prefix ",prefix," key ",key," value ",value," urn ", urn);
925.                 int keyLength = key.Length;
926.                 int valueLength = value.Length;
927.                 // table need for QName xsd types
928.                 if (key == null || keyLength == 0)
929.                     keyToNamespaceTable[prefix] = value;
930.                 else
931.                     keyToNamespaceTable[prefix+":"+key] = value;
933.                 if (keyLength == 2 && String.Compare(key, "id", true, CultureInfo.InvariantCulture) == 0)
934.                     pr.PRobjectId = objectReader.GetId(value);
935.                 else if (keyLength == 8 && String.Compare(key, "position", true, CultureInfo.InvariantCulture) == 0)
936.                     keyPosition = value;
937.                 else if (keyLength == 6 && String.Compare(key, "offset", true, CultureInfo.InvariantCulture) == 0)
938.                     keyOffset = value;
939.                 else if (keyLength == 14 && String.Compare(key, "MustUnderstand", true, CultureInfo.InvariantCulture) == 0)
940.                     keyMustUnderstand = value;
941.                 else if (keyLength == 4 && String.Compare(key, "null", true, CultureInfo.InvariantCulture) == 0)
942.                 {
943.                     pr.PRmemberValueEnum = InternalMemberValueE.Null;
944.                     pr.PRvalue = null;
945.                 }
946.                 else if (keyLength == 4 && String.Compare(key, "root", true, CultureInfo.InvariantCulture) == 0)
947.                 {
948.                     if (value.Equals("1"))
949.                         pr.PRisHeaderRoot = true;
950.                 }
951.                 else if (keyLength == 4 && String.Compare(key, "href", true, CultureInfo.InvariantCulture) == 0)
952.                     pr.PRidRef = objectReader.GetId(value);
953.                 else if (keyLength == 4 && String.Compare(key, "type", true, CultureInfo.InvariantCulture) == 0)
954.                 {
955.                     String currentPRtypeXmlKey = pr.PRtypeXmlKey;
956.                     String currentPRkeyDt = pr.PRkeyDt;
957.                     Type currentPRdtType = pr.PRdtType;
959.                     String typeValue = value;
960.                     int index = value.IndexOf(":");
961.                     if (index > 0)
962.                     {
963.                         pr.PRtypeXmlKey = value.Substring(0, index);
964.                         typeValue = value.Substring(++index);
965.                     }
966.                     else
967.                     {
968.                         pr.PRtypeXmlKey = prefix;                       
969.                     }
971.                     if (String.Compare(typeValue, "anyType", true, CultureInfo.InvariantCulture) == 0 || String.Compare(typeValue, "ur-type", true, CultureInfo.InvariantCulture) == 0)
972.                     {
973.                         pr.PRkeyDt = "System.Object";
974.                         pr.PRdtType = SoapUtil.typeofObject;
975.                         pr.PRtypeXmlKey = urtKey;
976.                     }
978.                     if (pr.PRtypeXmlKey == soapKey && typeValue == "Array") //Don't need to process xsi:type="SOAP-ENC:Array"
979.                     {
980.                         // Array values already found,use these value rather then the xsi:type values
981.                         pr.PRtypeXmlKey = currentPRtypeXmlKey;
982.                         pr.PRkeyDt = currentPRkeyDt;
983.                         pr.PRdtType = currentPRdtType;
984.                         InternalST.Soap( this,"ProcessAttributes, xsi:type='SOAP-ENC:Array' pr.PRtypeXmlKey ", pr.PRtypeXmlKey," pr.PRkeyDt "+pr.PRkeyDt);
985.                     }
986.                     else
987.                     {
988.                         pr.PRkeyDt = typeValue;
989.                         InternalST.Soap( this,"ProcessAttributes, not  xsi:type='SOAP-ENC:Array' pr.PRtypeXmlKey ", pr.PRtypeXmlKey," pr.PRkeyDt "+pr.PRkeyDt);
990.                     }
991.                 }
992.                 else if (keyLength == 9 && String.Compare(key, "arraytype", true, CultureInfo.InvariantCulture) == 0)
993.                 {
994.                     String typeValue = value;
995.                     int index = value.IndexOf(":");
996.                     if (index > 0)
997.                     {
998.                         pr.PRtypeXmlKey = value.Substring(0, index);
999.                         pr.PRkeyDt = typeValue = value.Substring(++index);
1000.                     }
1002.                     if (typeValue.StartsWith("ur_type["))
1003.                     {
1004.                         pr.PRkeyDt = "System.Object"+typeValue.Substring(6);
1005.                         pr.PRtypeXmlKey = urtKey;
1006.                     }
1007.                 }
1008.                 else if (SoapServices.IsClrTypeNamespace(value))
1009.                 {
1010.                     if (!assemKeyToAssemblyTable.ContainsKey(key))
1011.                     {
1012.                         String typeNamespace = null;
1013.                         String assemblyName = null;
1014.                         SoapServices.DecodeXmlNamespaceForClrTypeNamespace(value, out typeNamespace, out assemblyName);
1015.                         if (assemblyName == null)
1016.                         {
1017.                             assemKeyToAssemblyTable[key] = new SoapAssemblyInfo(SoapUtil.urtAssemblyString, SoapUtil.urtAssembly);
1018.                             assemKeyToNameSpaceTable[key] = typeNamespace;
1019.                         }
1020.                         else
1021.                         {
1022.                             assemKeyToAssemblyTable[key] = new SoapAssemblyInfo(assemblyName);
1023.                             if (typeNamespace != null)
1024.                                 assemKeyToNameSpaceTable[key] = typeNamespace;
1025.                         }
1027.                     }
1028.                 }
1029.                 else if ((prefixMatchesXmlns = prefix.Equals("xmlns")) && (valueLength == SoapKeyUrlLength && String.Compare(value, SoapKeyUrl, true, CultureInfo.InvariantCulture) == 0))
1030.                 {
1031.                     soapKey = key;
1032.                 }
1033.                 else if (prefixMatchesXmlns && (valueLength == UrtKeyUrlLength && String.Compare(value, UrtKeyUrl, true, CultureInfo.InvariantCulture) == 0))
1034.                 {
1035.                     urtKey = key;
1036.                     assemKeyToAssemblyTable[urtKey] = new SoapAssemblyInfo(SoapUtil.urtAssemblyString, SoapUtil.urtAssembly);
1037.                 }
1038.                 else if (prefixMatchesXmlns && (valueLength == SoapEnvKeyUrlLength && String.Compare(value, SoapEnvKeyUrl, true) == 0))
1039.                 {
1040.                     soapEnvKey = key;
1041.                 }
1042.                 else if (key == "encodingStyle")
1043.                 {
1044.                     /*
1045.                     String[] split = value.Split(' ');
1046.                     foreach (String s in split)
1047.                     {
1048.                         if (s == "http://schemas.microsoft.com/soap/encoding/clr/1.0")
1049.                         {
1050.                             objectReader.SetVersion(1,0);
1051.                             break;
1052.                         }
1053.                     }
1054.                     */
1055.                 }
1056.                 else if (prefixMatchesXmlns && 
1057.                          ((valueLength == XSIKey2001Length && String.Compare(value, XSIKey2001,true, CultureInfo.InvariantCulture) == 0) ||
1058.                           (valueLength == XSIKey1999Length && String.Compare(value, XSIKey1999,true, CultureInfo.InvariantCulture) == 0) ||
1059.                           (valueLength == XSIKey2000Length && String.Compare(value, XSIKey2000,true, CultureInfo.InvariantCulture) == 0)))
1060.                 {
1061.                     xsiKey = key;
1062.                 }
1063.                 else if (prefixMatchesXmlns && 
1064.                          ((valueLength == XSDKey2001Length && String.Compare(value, XSDKey2001 , true, CultureInfo.InvariantCulture) == 0)) ||
1065.                          (valueLength == XSDKey1999Length && String.Compare(value, XSDKey1999, true, CultureInfo.InvariantCulture) == 0) ||
1066.                          (valueLength == XSDKey2000Length && String.Compare(value, XSDKey2000, true, CultureInfo.InvariantCulture) == 0))
1067.                 {
1068.                     xsdKey = key;
1069.                 }
1070.                 else if (prefixMatchesXmlns && (valueLength == clrNSLength && String.Compare(value, clrNS, true, CultureInfo.InvariantCulture) == 0))
1071.                 {
1072.                     objectReader.SetVersion(1,0);
1073.                 }
1074.                 else
1075.                 {
1076.                     //String lowerCaseValue = value.ToLower(CultureInfo.InvariantCulture);
1077.                     if (prefixMatchesXmlns)
1078.                     {
1079.                         // Assume it is an interop namespace
1080.                         assemKeyToInteropAssemblyTable[key] = value;                        
1081.                         InternalST.Soap( this,"ProcessAttributes, InteropType key "+key+" value ",value);
1082.                     }
1083.                     else if (String.Compare(prefix, soapKey, true, CultureInfo.InvariantCulture) == 0)
1084.                     {
1085.                         InternalST.Soap( this,"ProcessAttributes, Not processed key ",prefix,":",key," = ",value);                  
1086.                     }
1087.                     else
1088.                     {
1089.                         // See if it is a XmlAttribute
1090.                         InternalST.Soap( this,"ProcessAttributes, XmlAttribute prefix ",prefix," key ",key," value ",value," urn ",urn, " hashtable ",assemKeyToInteropAssemblyTable[prefix]);
1092.                         if ((assemKeyToInteropAssemblyTable.ContainsKey(prefix)) && ((String)assemKeyToInteropAssemblyTable[prefix]).Equals(urn))
1093.                         {
1094.                             ProcessXmlAttribute(prefix, key, value, objectPr);
1095.                         }
1096.                         else
1097.                         {
1098.                             InternalST.Soap( this,"ProcessAttributes, Not processed prefix ",prefix," key ",key," value ",value," urn ",urn);
1099.                         }
1100.                     }
1101.                 }
1102.             }
1104.             attributeValues.Clear();
1106.             // reset the header state
1107.             // If no headers then headerState is None
1108.             //
1109.             // if parent is a header section then these are top level objects
1110.             // within the header section. If the object has a root set
1111.             // then it is a header record, if not then it is a toplevel object
1112.             // in the header section which is not a header record.
1113.             //
1114.             // if the parent is not a header section and is a header root
1115.             // then this is a nested object within a header record. All
1116.             // subsequent object will be nested until another header
1117.             // root is encountered
1118.             //
1119.             // The first header record is considered a root record
1120.             if (headerState != HeaderStateEnum.None)
1121.             {
1122.                 if (objectPr.PRparseTypeEnum == InternalParseTypeE.Headers)
1123.                 {
1124.                     if (pr.PRisHeaderRoot || (headerState == HeaderStateEnum.FirstHeaderRecord))
1125.                     {
1126.                         headerState = HeaderStateEnum.HeaderRecord;
1127.                     }
1128.                     else
1129.                     {
1130.                         headerState = HeaderStateEnum.TopLevelObject;
1131.                         currentState = InternalParseStateE.Object;
1132.                         pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
1133.                         pr.PRparseTypeEnum = InternalParseTypeE.Object;
1134.                         pr.PRparseStateEnum = InternalParseStateE.Object;
1135.                         pr.PRmemberTypeEnum = InternalMemberTypeE.Empty;
1136.                         pr.PRmemberValueEnum = InternalMemberValueE.Empty;
1137.                     }
1138.                 }
1139.                 else if (objectPr.PRisHeaderRoot)
1140.                     headerState = HeaderStateEnum.NestedObject;
1141.             }
1143.             InternalST.Soap( this,"ProcessAttributes, headerState ",((Enum)headerState).ToString());
1146.             if (!isTopFound && (objectPr != null ) && (objectPr.PRparseTypeEnum == InternalParseTypeE.Body))
1147.             {
1148.                 pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
1149.                 isTopFound = true;
1150.             }
1151.             else if (pr.PRobjectPositionEnum != InternalObjectPositionE.Top)
1152.                 pr.PRobjectPositionEnum = InternalObjectPositionE.Child;
1155.             // Don't process type for envelop, topSoapElement unless it has a key of soapEnvKey (SOAP-ENV). Fault
1156.             // is the only top record which currently falls into this category.
1157.             if (!((pr.PRparseTypeEnum == InternalParseTypeE.Envelope)||
1158.                   (pr.PRparseTypeEnum == InternalParseTypeE.Body) ||
1159.                   (pr.PRparseTypeEnum == InternalParseTypeE.Headers) ||
1160.                   (pr.PRobjectPositionEnum == InternalObjectPositionE.Top &
1161.                    objectReader.IsFakeTopObject &
1162.                    !pr.PRnameXmlKey.Equals(soapEnvKey))))
1163.             {
1164.                 InternalST.Soap( this, "ProcessAttributes  before Process Type ",((Enum)pr.PRparseTypeEnum).ToString());
1165.                 ProcessType(pr, objectPr);
1166.             }
1168.             if (keyPosition != null)
1169.             {
1170.                 int outRank;
1171.                 String outDimSignature;
1172.                 InternalArrayTypeE outArrayTypeEnum;
1173.                 pr.PRpositionA = ParseArrayDimensions(keyPosition, out outRank, out outDimSignature, out outArrayTypeEnum);
1174.             }
1176.             if (keyOffset != null)
1177.             {
1178.                 int outRank;
1179.                 String outDimSignature;
1180.                 InternalArrayTypeE outArrayTypeEnum;
1181.                 pr.PRlowerBoundA = ParseArrayDimensions(keyOffset, out outRank, out outDimSignature, out outArrayTypeEnum);
1182.             }
1184.             if (keyMustUnderstand != null)
1185.                 if (keyMustUnderstand.Equals("1"))
1186.                     pr.PRisMustUnderstand = true;
1187.                 else if (keyMustUnderstand.Equals("0"))
1188.                     pr.PRisMustUnderstand = false;
1189.                 else
1190.                     throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_MustUnderstand"),keyMustUnderstand));
1192.             if (pr.PRparseTypeEnum == InternalParseTypeE.Member)
1193.             {
1194.                 //  Process Member            
1196.                 InternalST.Soap( this, "ProcessAttributes  Member ");
1197.                 stack.Dump();
1199.                 if (objectPr.PRparseTypeEnum == InternalParseTypeE.Headers)
1200.                     pr.PRmemberTypeEnum = InternalMemberTypeE.Header;
1201.                 else if (objectPr.PRobjectTypeEnum == InternalObjectTypeE.Array)
1202.                     pr.PRmemberTypeEnum = InternalMemberTypeE.Item;
1203.                 else
1204.                     pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
1205.             }
1206.         }
1209.         // Create a URT type from the XML dt type
1210.         private void ProcessType(ParseRecord pr, ParseRecord objectPr)
1211.         {
1212.             InternalST.Soap( this, "ProcessType nameXmlKey ",pr.PRnameXmlKey," typeXmlKey ",pr.PRtypeXmlKey);
1213.             pr.Dump();
1214.             if (pr.PRdtType != null)
1215.                 return;
1216.             if ((pr.PRnameXmlKey.Equals(soapEnvKey)) && (String.Compare(pr.PRname, "Fault", true, CultureInfo.InvariantCulture) == 0))
1217.             {
1218.                 // Fault object
1219.                 InternalST.Soap( this, "ProcessType SoapFault");
1220.                 pr.PRdtType = SoapUtil.typeofSoapFault;
1221.                 pr.PRparseTypeEnum = InternalParseTypeE.Object;
1222.             }
1223.             else if (pr.PRname != null)
1224.             {
1225.                 InternalST.Soap( this, "ProcessType Attribute 1");              
1227.                 String interopAssemblyNameString = null;
1229.                 // determine interop assembly string if there is a namespace
1230.                 if ((pr.PRnameXmlKey != null) && (pr.PRnameXmlKey.Length > 0))
1231.                 {
1232.                     interopAssemblyNameString = (String)assemKeyToInteropAssemblyTable[pr.PRnameXmlKey];
1233.                     InternalST.Soap( this, "ProcessType Attribute 2 "+interopAssemblyNameString);               
1234.                 }
1236.                 // look for interop data
1237.                 Type type = null;
1238.                 String name = null;
1240.                 if (objectPr != null)
1241.                 {
1242.                     if (pr.PRisXmlAttribute)
1243.                     {
1244.                         //  These should processed after containing element
1245.                         //  is processed.
1246.                         SoapServices.GetInteropFieldTypeAndNameFromXmlAttribute(
1247.                                                                                objectPr.PRdtType, pr.PRname, interopAssemblyNameString,
1248.                                                                                out type, out name);
1249.                         InternalST.Soap( this, "ProcessType Attribute 3 type "+type+" name "+name);
1250.                     }
1251.                     else
1252.                     {
1253.                         SoapServices.GetInteropFieldTypeAndNameFromXmlElement(
1254.                                                                              objectPr.PRdtType, pr.PRname, interopAssemblyNameString,
1255.                                                                              out type, out name);
1256.                         InternalST.Soap( this, "ProcessType Attribute 4 type objectPr.PRdtType ",objectPr.PRdtType," pr.PRname ",pr.PRname, " interopAssemblyNameString ",interopAssemblyNameString, " type ",type," name ",name);
1257.                     }
1258.                 }
1260.                 if (type != null)
1261.                 {
1262.                     pr.PRdtType = type;
1263.                     pr.PRname = name;
1264.                     pr.PRdtTypeCode = Converter.SoapToCode(pr.PRdtType);
1265.                     InternalST.Soap(this, "ProcessType Attribute 5 typeCode "+((Enum)pr.PRdtTypeCode));
1266.                 }
1267.                 else
1268.                 {
1269.                     if (interopAssemblyNameString != null)
1270.                         pr.PRdtType = objectReader.Bind(interopAssemblyNameString, pr.PRname); // try to get type from SerializationBinder
1271.                     if (pr.PRdtType == null)
1272.                     {
1273.                         pr.PRdtType = SoapServices.GetInteropTypeFromXmlElement(pr.PRname, interopAssemblyNameString);
1274.                     }
1276.                     // Array item where the element name gives the element type
1277.                     if (pr.PRkeyDt == null && pr.PRnameXmlKey != null && pr.PRnameXmlKey.Length > 0 && objectPr.PRobjectTypeEnum == InternalObjectTypeE.Array && objectPr.PRarrayElementType == Converter.typeofObject)
1278.                     {
1279.                             pr.PRdtType = ProcessGetType(pr.PRname, pr.PRnameXmlKey, out pr.PRassemblyName);
1280.                             pr.PRdtTypeCode = Converter.SoapToCode(pr.PRdtType);
1281.                     }
1283.                     InternalST.Soap(this, "ProcessType Attribute 6 type pr.PRname ", pr.PRname, " interopAssemblyNameString ",interopAssemblyNameString, " pr.PRdtType ",pr.PRdtType);
1284.                 }
1286.             }
1288.             if (pr.PRdtType != null)
1289.                 return;
1291.             if ((pr.PRtypeXmlKey != null) && (pr.PRtypeXmlKey.Length > 0) && 
1292.                 (pr.PRkeyDt != null) && (pr.PRkeyDt.Length > 0) && 
1293.                 (assemKeyToInteropAssemblyTable.ContainsKey(pr.PRtypeXmlKey)))
1294.             {
1295.                 InternalST.Soap(this, "ProcessType Attribute 7 ");
1296.                 // Interop type get from dtType
1297.                 int index = pr.PRkeyDt.IndexOf("[");
1298.                 if (index > 0)
1299.                 {
1300.                     ProcessArray(pr, index, true);
1301.                 }
1302.                 else
1303.                 {
1304.                     String assemblyString = (String)assemKeyToInteropAssemblyTable[pr.PRtypeXmlKey];
1305.                     pr.PRdtType = objectReader.Bind(assemblyString, pr.PRkeyDt); // try to get type from SerializationBinder
1306.                     if (pr.PRdtType == null)
1307.                     {
1308.                         pr.PRdtType = SoapServices.GetInteropTypeFromXmlType(pr.PRkeyDt, assemblyString); 
1309.                         if (pr.PRdtType == null)
1310.                             throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeElement"),pr.PRname+" "+pr.PRkeyDt));
1311.                     }
1312.                     InternalST.Soap(this, "ProcessType Attribute 8 type pr.PRkeyDt ",pr.PRkeyDt," pr.PRdtType ",pr.PRdtType);
1313.                     if (pr.PRdtType == null)
1314.                     {
1315.                         throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeElement"),pr.PRname+" "+pr.PRkeyDt+", "+assemblyString));   
1316.                     }
1317.                 }
1318.             }
1319.             else if (pr.PRkeyDt != null)
1320.             {
1321.                 if (String.Compare(pr.PRkeyDt, "Base64", true, CultureInfo.InvariantCulture) == 0)
1322.                 {
1323.                     pr.PRobjectTypeEnum = InternalObjectTypeE.Array;
1324.                     pr.PRarrayTypeEnum = InternalArrayTypeE.Base64;
1325.                 }
1326.                 else if (String.Compare(pr.PRkeyDt, "String", true, CultureInfo.InvariantCulture) == 0)
1327.                 {
1328.                     pr.PRdtType = SoapUtil.typeofString;
1329.                 }
1330.                 else if (String.Compare(pr.PRkeyDt, "methodSignature", true, CultureInfo.InvariantCulture) == 0)
1331.                 {
1332.                     // MethodSignature needs to be expanded to an array of types
1333.                     InternalST.Soap( this, "ProcessType methodSignature ",pr.PRvalue);
1334.                     try
1335.                     {
1336.                         pr.PRdtType = typeof(System.Type[]);
1337.                         char[] c = {' ', ':'};
1338.                         String[] typesStr = null;
1339.                         if (pr.PRvalue != null)
1340.                             typesStr = pr.PRvalue.Split(c);
1341.                         Type[] types = null;
1342.                         if ((typesStr == null) ||
1343.                             (typesStr.Length == 1 && typesStr[0].Length == 0))
1344.                         {
1345.                             // Method signature with no parameters
1346.                             types = new Type[0];
1347.                         }
1348.                         else
1349.                         {
1350.                             types = new Type[typesStr.Length/2];
1351.                             //throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_MethodSignature"),pr.PRvalue));                    
1353.                             for (int i=0; i<typesStr.Length; i+=2)
1354.                             {
1355.                                 String prefix = typesStr[i];
1356.                                 String typeString = typesStr[i+1];
1357.                                 types[i/2] = ProcessGetType(typeString, prefix, out pr.PRassemblyName);
1358.                                 InternalST.Soap( this, "ProcessType methodSignature type string ",i+" "+" prefix "+prefix+" typestring "+typeString+" type "+types[i/2]); //Temp
1359.                             }
1360.                         }
1361.                         pr.PRvarValue = types;
1362.                     }
1363.                     catch (Exception)
1364.                     {
1365.                         throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_MethodSignature"),pr.PRvalue));
1366.                     }
1367.                 }
1368.                 else
1369.                 {
1370.                     pr.PRdtTypeCode = Converter.ToCode(pr.PRkeyDt);
1371.                     if (pr.PRdtTypeCode != InternalPrimitiveTypeE.Invalid)
1372.                     {
1373.                         pr.PRdtType = Converter.SoapToType(pr.PRdtTypeCode);
1374.                     }
1375.                     else
1376.                     {
1377.                         // Find out if it is an array
1378.                         int index = pr.PRkeyDt.IndexOf("[");
1379.                         if (index > 0)
1380.                         {
1381.                             // Array
1382.                             ProcessArray(pr, index, false);
1383.                         }
1384.                         else
1385.                         {
1386.                             // Object
1387.                             pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
1388.                             pr.PRdtType = ProcessGetType(pr.PRkeyDt, pr.PRtypeXmlKey, out pr.PRassemblyName);
1389.                             if ((pr.PRdtType == null) && (pr.PRobjectPositionEnum != InternalObjectPositionE.Top))
1390.                                 throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeElement"),pr.PRname+" "+pr.PRkeyDt));
1391.                         }
1392.                     }
1393.                     InternalST.Soap(this, "ProcessType Attribute 9 type "+pr.PRdtType);
1394.                 }
1395.             }
1396.             else
1397.             {
1398.                 if ((pr.PRparseTypeEnum == InternalParseTypeE.Object) && (!(objectReader.IsFakeTopObject && (pr.PRobjectPositionEnum == InternalObjectPositionE.Top))))
1399.                 {
1400.                     if (String.Compare(pr.PRname, "Array", true, CultureInfo.InvariantCulture) == 0)
1401.                         pr.PRdtType = ProcessGetType(pr.PRkeyDt, pr.PRtypeXmlKey, out pr.PRassemblyName);
1402.                     else
1403.                     {
1404.                         pr.PRdtType = ProcessGetType(pr.PRname, pr.PRnameXmlKey, out pr.PRassemblyName);
1405.                     }
1406.                     InternalST.Soap(this, "ProcessType Attribute 10 type "+pr.PRdtType);
1407.                 }
1409.             } 
1410.         }
1412.         private Type ProcessGetType(String value, String xmlKey, out String assemblyString)
1413.         {
1414.             InternalST.Soap( this, "ProcessGetType Entry xmlKey ",xmlKey," value ",value);
1415.             Type type = null;
1416.             String typeValue = null;
1417.             assemblyString = null;
1419.             // If there is an attribute which matches a preloaded type, then return the preloaded type
1420.             String httpstring = (String)keyToNamespaceTable["xmlns:"+xmlKey];
1421.             if (httpstring != null)
1422.             {
1423.                 type= GetInteropType(value, httpstring);
1424.                 if (type != null)
1425.                     return type;
1426.             }
1429.             if ((String.Compare(value, "anyType", true, CultureInfo.InvariantCulture) == 0 || String.Compare(value, "ur-type", true, CultureInfo.InvariantCulture) == 0) && (xmlKey.Equals(xsdKey)))
1430.                 type = SoapUtil.typeofObject;
1431.             else if ((xmlKey.Equals(xsdKey)) || (xmlKey.Equals(soapKey)))
1432.             {
1433.                 if (String.Compare(value, "string", true, CultureInfo.InvariantCulture) == 0)
1434.                 {
1435.                     type = SoapUtil.typeofString;
1436.                 }
1437.                 else
1438.                 {
1439.                     InternalPrimitiveTypeE code = Converter.ToCode(value);
1440.                     if (code == InternalPrimitiveTypeE.Invalid)
1441.                         throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_Parser_xsd"),value));
1443.                     type = Converter.SoapToType(code);
1444.                 }
1445.             }
1446.             else
1447.             {
1448.                 if ( xmlKey == null)
1449.                     throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_Parser_xml"),value));
1451.                 String nameSpace = (String)assemKeyToNameSpaceTable[xmlKey];
1452.                 typeValue = null;
1453.                 if (nameSpace == null)
1454.                     typeValue = value;
1455.                 else
1456.                     typeValue = nameSpace+"."+value;
1458.                 SoapAssemblyInfo assemblyInfo = (SoapAssemblyInfo)assemKeyToAssemblyTable[xmlKey];
1459.                 if (assemblyInfo == null)
1460.                     throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_Parser_xmlAssembly"),xmlKey+" "+value));
1462.                 assemblyString = assemblyInfo.assemblyString;
1463.                 if (assemblyString != null)
1464.                 {
1465.                     // See if a SerializationBinder was defined to resolve this type
1466.                     type = objectReader.Bind(assemblyString, typeValue);
1467.                     if (type == null)
1468.                         type= objectReader.FastBindToType(assemblyString, typeValue);
1469.                 }
1471.                 if (type == null)
1472.                 {
1473.                     Assembly assembly = null;
1474.                     try
1475.                     {
1476.                         assembly = assemblyInfo.GetAssembly(objectReader);
1477.                     }
1478.                     catch (Exception)
1479.                     {
1480.                     }
1482.                     if (assembly == null)
1483.                         throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_Parser_xmlAssembly"),xmlKey+":"+httpstring+" "+value));
1484.                     else
1485.                         type = FormatterServices.GetTypeFromAssembly(assembly, typeValue);
1486.                 }
1487.             }
1488.             if (type == null)
1489.                 throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_Parser_xmlType"),xmlKey+" "+typeValue+" "+assemblyString));
1490.             InternalST.Soap( this, "ProcessGetType Exit ",type);
1491.             return type;            
1492.         }
1494.         private Type GetInteropType(String value, String httpstring)
1495.         {
1496.             // For the case where the client dll has a different name from the server dll
1497.             // The assembly name returned in soap won't match the assembly name in the client dll.
1498.             // so the custom attributes are needed to map from the Soap assembly name to the client assembly
1499.             // This map can only work if the client type was preloaded.
1500.             Type type = SoapServices.GetInteropTypeFromXmlType(value, httpstring); 
1501.             if (type == null)
1502.             {
1503.                 // try simple assembly name
1504.                 int index = httpstring.IndexOf("%2C");
1505.                 if (index > 0)
1506.                 {
1507.                     String simpleAssem = httpstring.Substring(0,index);
1508.                     type = SoapServices.GetInteropTypeFromXmlType(value, simpleAssem); 
1509.                 }
1510.             }
1511.             return type;
1512.         }
1515.         // Determine the Array  information from the dt attribute
1516.         private void ProcessArray(ParseRecord pr, int firstIndex, bool IsInterop)
1517.         {
1518.             InternalST.Soap( this, "ProcessArray Enter ",firstIndex," ",pr.PRkeyDt);
1519.             String dimString = null;
1520.             String xmlKey = pr.PRtypeXmlKey;
1521.             InternalPrimitiveTypeE primitiveArrayTypeCode = InternalPrimitiveTypeE.Invalid;
1522.             pr.PRobjectTypeEnum = InternalObjectTypeE.Array;
1523.             pr.PRmemberTypeEnum = InternalMemberTypeE.Item; // Need this set in case this it is a nested empty array
1524.             pr.PRprimitiveArrayTypeString = pr.PRkeyDt.Substring(0, firstIndex);
1525.             dimString = pr.PRkeyDt.Substring(firstIndex);
1526.             if (IsInterop)
1527.             {
1528.                 String assemblyString = (String)assemKeyToInteropAssemblyTable[pr.PRtypeXmlKey];
1529.                 pr.PRarrayElementType = objectReader.Bind(assemblyString, pr.PRprimitiveArrayTypeString); // try to get type from SerializationBinder
1530.                 if (pr.PRarrayElementType == null)
1531.                     pr.PRarrayElementType = SoapServices.GetInteropTypeFromXmlType(pr.PRprimitiveArrayTypeString, assemblyString);
1532.                 if (pr.PRarrayElementType == null)
1533.                     throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeElement"),pr.PRname+" "+pr.PRkeyDt));
1534.                 pr.PRprimitiveArrayTypeString = pr.PRarrayElementType.FullName;
1535.             }
1536.             else
1537.             {
1538.                 primitiveArrayTypeCode = Converter.ToCode(pr.PRprimitiveArrayTypeString);
1539.                 if (primitiveArrayTypeCode != InternalPrimitiveTypeE.Invalid)
1540.                 {
1541.                     pr.PRprimitiveArrayTypeString = Converter.SoapToComType(primitiveArrayTypeCode);
1542.                     xmlKey = urtKey;
1543.                 }
1544.                 else if (String.Compare(pr.PRprimitiveArrayTypeString, "string", false, CultureInfo.InvariantCulture) == 0)
1545.                 {
1546.                     pr.PRprimitiveArrayTypeString = "System.String";
1547.                     xmlKey = urtKey;
1548.                 }
1549.                 else if (String.Compare(pr.PRprimitiveArrayTypeString, "anyType", false, CultureInfo.InvariantCulture) == 0 || String.Compare(pr.PRprimitiveArrayTypeString, "ur-type", false, CultureInfo.InvariantCulture) == 0)
1550.                 {
1551.                     pr.PRprimitiveArrayTypeString = "System.Object";
1552.                     xmlKey = urtKey;
1553.                 }
1554.             }
1556.             int beginIndex = firstIndex;
1557.             int endIndex = pr.PRkeyDt.IndexOf(']', beginIndex+1);
1558.             if (endIndex < 1)
1559.                 throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_ArrayDimensions"),pr.PRkeyDt));
1561.             int outRank = 0;
1562.             int[] outDimensions = null;
1563.             String outDimSignature = null;
1564.             InternalArrayTypeE outArrayTypeEnum = InternalArrayTypeE.Empty;
1565.             int numBrackets = 0;
1567.             StringBuilder elementSig = new StringBuilder(10);
1569.             while (true)
1570.             {
1571.                 numBrackets++;
1572.                 outDimensions = ParseArrayDimensions(pr.PRkeyDt.Substring(beginIndex, endIndex-beginIndex+1), out outRank, out outDimSignature, out outArrayTypeEnum);
1573.                 if (endIndex+1 == pr.PRkeyDt.Length)
1574.                     break;
1575.                 elementSig.Append(outDimSignature); // Don't want last dimension in element sig
1576.                 beginIndex = endIndex+1;
1577.                 endIndex = pr.PRkeyDt.IndexOf(']', beginIndex);
1578.             }
1580.             pr.PRlengthA = outDimensions;
1581.             pr.PRrank = outRank;
1584.             if (numBrackets == 1)
1585.             {
1586.                 pr.PRarrayElementTypeCode = primitiveArrayTypeCode;
1587.                 pr.PRarrayTypeEnum = outArrayTypeEnum;
1588.                 pr.PRarrayElementTypeString = pr.PRprimitiveArrayTypeString;            
1589.             }
1590.             else
1591.             {
1592.                 pr.PRarrayElementTypeCode = InternalPrimitiveTypeE.Invalid;
1593.                 pr.PRarrayTypeEnum = InternalArrayTypeE.Rectangular;            
1594.                 pr.PRarrayElementTypeString = pr.PRprimitiveArrayTypeString+elementSig.ToString();
1596.             }
1598.             InternalST.Soap( this, "ProcessArray GetType ",pr.PRarrayElementType);
1599.             if (!IsInterop || numBrackets > 1)
1600.             {
1601.                 pr.PRarrayElementType = ProcessGetType(pr.PRarrayElementTypeString, xmlKey, out pr.PRassemblyName);
1602.                 if (pr.PRarrayElementType == null)
1603.                     throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_ArrayType"),pr.PRarrayElementType));
1605.                 if ((pr.PRarrayElementType == SoapUtil.typeofObject))
1606.                 {
1607.                     pr.PRisArrayVariant = true;
1608.                     xmlKey = urtKey;
1609.                 }
1610.             }
1612.             InternalST.Soap( this, "ProcessArray Exit");
1613.         }
1615.         // Parse an array dimension bracket
1616.         private int[] ParseArrayDimensions(String dimString, out int rank, out String dimSignature, out InternalArrayTypeE arrayTypeEnum)
1617.         {
1618.             InternalST.Soap( this, "ProcessArrayDimensions Enter ",dimString);      
1619.             char[] dimArray = dimString.ToCharArray();
1621.             int paramCount = 0;
1622.             int commaCount = 0;
1623.             int rankCount = 0;
1624.             int[] dim = new int[dimArray.Length];
1627.             StringBuilder sb = new StringBuilder(10);
1628.             StringBuilder sigSb = new StringBuilder(10);
1630.             for (int i=0; i<dimArray.Length; i++)
1631.             {
1632.                 if (dimArray[i] == '[')
1633.                 {
1634.                     paramCount++;
1635.                     sigSb.Append(dimArray[i]);
1636.                 }
1637.                 else if (dimArray[i] == ']')
1638.                 {
1639.                     if (sb.Length > 0)
1640.                     {
1641.                         dim[rankCount++] = Int32.Parse(sb.ToString(), CultureInfo.InvariantCulture);
1642.                         sb.Length = 0;
1643.                     }
1644.                     sigSb.Append(dimArray[i]);                  
1645.                 }
1646.                 else if (dimArray[i] == ',')
1647.                 {
1648.                     commaCount++;
1649.                     if (sb.Length > 0)
1650.                     {
1651.                         dim[rankCount++] = Int32.Parse(sb.ToString(), CultureInfo.InvariantCulture);
1652.                         sb.Length = 0;
1653.                     }
1654.                     sigSb.Append(dimArray[i]);                      
1655.                 }
1656.                 else if ((dimArray[i] == '-') || (Char.IsDigit(dimArray[i])))
1657.                 {
1658.                     sb.Append(dimArray[i]);
1659.                 }
1660.                 else
1661.                     throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_ArrayDimensions"),dimString));
1662.             }
1664.             rank = rankCount;
1665.             dimSignature = sigSb.ToString();
1666.             int[] dimA = new int[rank];
1667.             for (int i=0; i<rank; i++)
1668.             {
1669.                 dimA[i] = dim[i];
1670.             }
1672.             InternalArrayTypeE outEnum = InternalArrayTypeE.Empty;
1674.             if (commaCount > 0)
1675.                 outEnum = InternalArrayTypeE.Rectangular;
1676.             else
1677.                 outEnum = InternalArrayTypeE.Single;
1679.             arrayTypeEnum = outEnum;
1681.             InternalST.Soap( this, "ProcessArrayDimensions length ",PArray(dimA));
1682.             InternalST.Soap( this, "ProcessArrayDimensions Exit rank ",rank," dimSignature ",sigSb.ToString()," arrayTypeEnum ",((Enum)outEnum).ToString());
1684.             return dimA;
1685.         }
1687.         // Converts a single int array to a string
1689.         private String PArray(int[] array)
1690.         {
1691.             if (array != null)
1692.             {
1693.                 StringBuilder sb = new StringBuilder(10);
1694.                 sb.Append("[");     
1695.                 for (int i=0; i<array.Length; i++)
1696.                 {
1697.                     sb.Append(array[i]);
1698.                     if (i != array.Length -1)
1699.                         sb.Append(",");
1700.                 }
1701.                 sb.Append("]");
1702.                 return sb.ToString();
1703.             }
1704.             else
1705.                 return "";
1706.         }
1709.         StringBuilder stringBuffer = new StringBuilder(120);
1711.         // Filter an element name for $ and leading digit
1713.         NameCache nameCache = new NameCache();
1714.         private String NameFilter(String name)
1715.         {
1716.             String value = (String)nameCache.GetCachedValue(name);
1717.             if (value == null)
1718.             {
1719.                 value = System.Xml.XmlConvert.DecodeName(name);
1720.                 nameCache.SetCachedValue(value);
1721.             }
1722.             return value;
1723.         }
1725.         ArrayList xmlAttributeList = null;
1727.         private void ProcessXmlAttribute(String prefix, String key, String value, ParseRecord objectPr)
1728.         {
1729.             InternalST.Soap( this,"ProcessXmlAttribute prefix ",prefix, " key ", key, " value ",value);         
1730.             if (xmlAttributeList == null)
1731.                 xmlAttributeList = new ArrayList(10);
1732.             ParseRecord pr = GetPr();
1733.             pr.PRparseTypeEnum = InternalParseTypeE.Member;
1734.             pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
1735.             pr.PRmemberValueEnum = InternalMemberValueE.InlineValue;
1736.             pr.PRname = key;
1737.             pr.PRvalue = value;
1738.             pr.PRnameXmlKey = prefix;
1739.             pr.PRisXmlAttribute = true;
1741.             ProcessType(pr, objectPr);
1743.             xmlAttributeList.Add(pr);
1744.         }
1746.         ArrayList headerList = null;
1747.         int headerArrayLength;
1749.         private void ProcessHeader(ParseRecord pr)
1750.         {
1751.             InternalST.Soap( this,"ProcessHeader ");
1752.             pr.Dump();
1754.             if (headerList == null)
1755.                 headerList = new ArrayList(10);
1756.             ParseRecord headerPr = GetPr();
1757.             headerPr.PRparseTypeEnum = InternalParseTypeE.Object;
1758.             headerPr.PRobjectTypeEnum = InternalObjectTypeE.Array;
1759.             headerPr.PRobjectPositionEnum = InternalObjectPositionE.Headers;
1760.             headerPr.PRarrayTypeEnum = InternalArrayTypeE.Single;
1761.             headerPr.PRarrayElementType = typeof(System.Runtime.Remoting.Messaging.Header);
1762.             headerPr.PRisArrayVariant = false;
1763.             headerPr.PRarrayElementTypeCode = InternalPrimitiveTypeE.Invalid;
1764.             headerPr.PRrank = 1;
1765.             headerPr.PRlengthA = new int[1];                
1766.             headerList.Add(headerPr);
1767.         }
1769.         private void ProcessHeaderMember(ParseRecord pr)
1770.         {
1771.             ParseRecord headerPr;
1773.             InternalST.Soap( this,"ProcessHeaderMember HeaderState ",((Enum)headerState).ToString());
1774.             pr.Dump(); 
1776.             if (headerState == HeaderStateEnum.NestedObject)
1777.             {
1778.                 // Nested object in Header member
1779.                 ParseRecord newPr = pr.Copy();
1780.                 headerList.Add(newPr);
1781.                 return;
1782.             }
1784.             // Item record
1785.             headerPr = GetPr();
1786.             headerPr.PRparseTypeEnum = InternalParseTypeE.Member;
1787.             headerPr.PRmemberTypeEnum = InternalMemberTypeE.Item;
1788.             headerPr.PRmemberValueEnum = InternalMemberValueE.Nested;
1789.             headerPr.PRisHeaderRoot = true;
1790.             headerArrayLength++;
1791.             headerList.Add(headerPr);
1793.             // Name field
1794.             headerPr = GetPr();
1795.             headerPr.PRparseTypeEnum = InternalParseTypeE.Member;
1796.             headerPr.PRmemberTypeEnum = InternalMemberTypeE.Field;
1797.             headerPr.PRmemberValueEnum = InternalMemberValueE.InlineValue;
1798.             headerPr.PRisHeaderRoot = true;
1799.             headerPr.PRname = "Name";
1800.             headerPr.PRvalue = pr.PRname;
1801.             headerPr.PRdtType = SoapUtil.typeofString;
1802.             headerPr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
1803.             headerList.Add(headerPr);
1805.             // Namespace field
1806.             headerPr = GetPr();
1807.             headerPr.PRparseTypeEnum = InternalParseTypeE.Member;
1808.             headerPr.PRmemberTypeEnum = InternalMemberTypeE.Field;
1809.             headerPr.PRmemberValueEnum = InternalMemberValueE.InlineValue;
1810.             headerPr.PRisHeaderRoot = true;
1811.             headerPr.PRname = "HeaderNamespace";
1812.             headerPr.PRvalue = pr.PRxmlNameSpace;
1813.             headerPr.PRdtType = SoapUtil.typeofString;
1814.             headerPr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
1815.             headerList.Add(headerPr);
1817.             // MustUnderstand Field
1818.             headerPr = GetPr();
1819.             headerPr.PRparseTypeEnum = InternalParseTypeE.Member;
1820.             headerPr.PRmemberTypeEnum = InternalMemberTypeE.Field;
1821.             headerPr.PRmemberValueEnum = InternalMemberValueE.InlineValue;
1822.             headerPr.PRisHeaderRoot = true;         
1823.             headerPr.PRname = "MustUnderstand";
1824.             if (pr.PRisMustUnderstand)
1825.                 headerPr.PRvarValue = true;
1826.             else
1827.                 headerPr.PRvarValue = false;            
1828.             headerPr.PRdtType = SoapUtil.typeofBoolean;
1829.             headerPr.PRdtTypeCode = InternalPrimitiveTypeE.Boolean;
1830.             headerList.Add(headerPr);       
1832.             // Value field
1833.             headerPr = GetPr();
1834.             headerPr.PRparseTypeEnum = InternalParseTypeE.Member;
1835.             headerPr.PRmemberTypeEnum = InternalMemberTypeE.Field;
1836.             headerPr.PRmemberValueEnum = pr.PRmemberValueEnum;
1837.             headerPr.PRisHeaderRoot = true;         
1838.             headerPr.PRname = "Value";
1839.             switch (pr.PRmemberValueEnum)
1840.             {
1841.                 case InternalMemberValueE.Null:
1842.                     headerList.Add(headerPr);
1843.                     ProcessHeaderMemberEnd(pr);
1844.                     break;
1845.                 case InternalMemberValueE.Reference:
1846.                     headerPr.PRidRef = pr.PRidRef;
1847.                     headerList.Add(headerPr);
1848.                     ProcessHeaderMemberEnd(pr);             
1849.                     break;
1850.                 case InternalMemberValueE.Nested:
1851.                     headerPr.PRdtType = pr.PRdtType;
1852.                     headerPr.PRdtTypeCode = pr.PRdtTypeCode;
1853.                     headerPr.PRkeyDt = pr.PRkeyDt;
1854.                     headerList.Add(headerPr);
1855.                     // ProcessHeaderMemberEnd will be called from the parse loop
1856.                     break;
1858.                 case InternalMemberValueE.InlineValue:
1859.                     headerPr.PRvalue = pr.PRvalue;
1860.                     headerPr.PRvarValue = pr.PRvarValue;
1861.                     headerPr.PRdtType = pr.PRdtType;
1862.                     headerPr.PRdtTypeCode = pr.PRdtTypeCode;
1863.                     headerPr.PRkeyDt = pr.PRkeyDt;
1864.                     headerList.Add(headerPr);
1865.                     ProcessHeaderMemberEnd(pr);             
1866.                     break;
1867.             }
1868.         }
1870.         private void ProcessHeaderMemberEnd(ParseRecord pr)
1871.         {
1872.             ParseRecord headerPr = null;
1874.             InternalST.Soap( this,"ProcessHeaderMemberEnd HeaderState ",((Enum)headerState).ToString());
1875.             pr.Dump(); 
1877.             if (headerState == HeaderStateEnum.NestedObject)
1878.             {
1879.                 ParseRecord newPr = pr.Copy();
1880.                 headerList.Add(newPr);
1881.             }
1882.             else
1883.             {
1884.                 // Member End
1885.                 headerPr = GetPr();
1886.                 headerPr.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
1887.                 headerPr.PRmemberTypeEnum = InternalMemberTypeE.Field;
1888.                 headerPr.PRmemberValueEnum = pr.PRmemberValueEnum;
1889.                 headerPr.PRisHeaderRoot = true;
1890.                 headerList.Add(headerPr);
1892.                 // Item End
1893.                 headerPr = GetPr();
1894.                 headerPr.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
1895.                 headerPr.PRmemberTypeEnum = InternalMemberTypeE.Item;
1896.                 headerPr.PRmemberValueEnum = InternalMemberValueE.Nested;
1897.                 headerPr.PRisHeaderRoot = true;             
1898.                 headerList.Add(headerPr);
1899.             }
1900.         }
1903.         private void ProcessHeaderEnd(ParseRecord pr)
1904.         {
1905.             InternalST.Soap( this,"ProcessHeaderEnd ");
1906.             pr.Dump();
1908.             if (headerList == null)
1909.                 return; // Empty header array
1912.             // Object End
1913.             ParseRecord headerPr = GetPr();
1914.             headerPr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
1915.             headerPr.PRobjectTypeEnum = InternalObjectTypeE.Array;
1916.             headerList.Add(headerPr);
1918.             headerPr = (ParseRecord)headerList[0];
1919.             headerPr = (ParseRecord)headerList[0];
1920.             headerPr.PRlengthA[0] = headerArrayLength;
1921.             headerPr.PRobjectPositionEnum = InternalObjectPositionE.Headers;            
1923.             for (int i=0; i<headerList.Count; i++)
1924.             {
1925.                 InternalST.Soap( this, "Parse Header Record ",i);
1926.                 InternalST.Soap( this,"ObjectReader.Parse 9");              
1927.                 objectReader.Parse((ParseRecord)headerList[i]);
1928.             }
1930.             for (int i=0; i<headerList.Count; i++)
1931.                 PutPr((ParseRecord)headerList[i]);
1932.         }
1934.         [Serializable]
1935.         enum HeaderStateEnum
1936.         {
1937.             None = 0,
1938.             FirstHeaderRecord = 1,
1939.             HeaderRecord = 2,
1940.             NestedObject = 3,
1941.             TopLevelObject = 4,
1942.         }
1943.     }
1944. }