The Labs \ Source Viewer \ SSCLI \ System.Runtime.Remoting.MetadataServices \ ReaderStream

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. //============================================================
  16. //
  17. // File: SdlParser.cs
  18. // Summary: Defines SdlParser that parses a given SUDS document
  19. // and generates types defined in it.
  20. //
  21. // Date: April 01, 2000
  22. // Revised: November 15, 2000 (Wsdl)
  23. //
  24. //============================================================
  25. namespace System.Runtime.Remoting.MetadataServices
  26. {
  27.     using System;
  28.     using System.Threading;
  29.     using System.Collections;
  30.     using System.Reflection;
  31.     using System.Xml;
  32.     using System.Diagnostics;
  33.     using System.IO;
  34.     using System.Text;
  35.     using System.Net;
  36.     using System.Runtime.Remoting.Channels;
  37.     // This is so we can get the resource strings.
  38.     using System.Runtime.Remoting;
  39.     using System.Globalization;
  40.    
  41.    
  42.     // This class parses SUDS documents
  43.     internal class SdlParser
  44.     {
  45.        
  46.         // XML document validation callback
  47.         private void ValidationCallback(int hr, string reason)
  48.         {
  49.             StringBuilder sb = new StringBuilder("Validation Error:", 256);
  50.             sb.Append(reason);
  51.             sb.Append('(');
  52.             sb.Append(hr);
  53.             sb.Append(')');
  54.             Console.WriteLine(sb);
  55.         }
  56.        
  57.         // Main parser
  58.         internal SdlParser(TextReader input, string outputDir, ArrayList outCodeStreamList, string locationURL, bool bWrappedProxy)
  59.         {
  60.             Util.Log("SdlParser.SdlParser outputDir " + outputDir + " locationURL " + locationURL + " bWrappedProxy " + bWrappedProxy);
  61.             // Initialize member variables
  62.             _XMLReader = null;
  63.             _readerStreams = new ReaderStream(locationURL);
  64.             _readerStreams.InputStream = input;
  65.             _writerStreams = null;
  66.             _outputDir = outputDir;
  67.             _outCodeStreamList = outCodeStreamList;
  68.             _bWrappedProxy = bWrappedProxy;
  69.             if (outputDir == null)
  70.                 outputDir = ".";
  71.            
  72.             int length = outputDir.Length;
  73.             if (length > 0) {
  74.                 char endChar = outputDir[length - 1];
  75.                 if (endChar != '\\' && endChar != '/')
  76.                     _outputDir = _outputDir + '\\';
  77.             }
  78.             //_namespaceStack = null;
  79.             _URTNamespaces = new ArrayList();
  80.             _blockDefault = SchemaBlockType.ALL;
  81.         }
  82.        
  83.         // Prints an XML node
  84.         private void PrintNode(TextWriter textWriter)
  85.         {
  86.             Util.Log("SdlParser.PrintNode");
  87.             if (textWriter == null)
  88.                 textWriter = Console.Out;
  89.             _XMLReader.MoveToElement();
  90.             textWriter.WriteLine("===========================");
  91.             textWriter.WriteLine("LineNum : " + _XMLReader.LineNumber);
  92.             StringBuilder sb = new StringBuilder("NodeType : ", 256);
  93.             sb.Append((int)_XMLReader.NodeType);
  94.             textWriter.WriteLine(sb);
  95.             sb.Length = 0;
  96.             sb.Append("Name : ");
  97.             sb.Append(_XMLReader.LocalName);
  98.             textWriter.WriteLine(sb);
  99.             sb.Length = 0;
  100.             sb.Append("Namespace : ");
  101.             sb.Append(_XMLReader.NamespaceURI);
  102.             textWriter.WriteLine(sb);
  103.             sb.Length = 0;
  104.             sb.Append("Prefix : ");
  105.             sb.Append(_XMLReader.Prefix);
  106.             textWriter.WriteLine(sb);
  107.             sb.Length = 0;
  108.             sb.Append("Hasvalue : ");
  109.             sb.Append(_XMLReader.HasValue);
  110.             textWriter.WriteLine(sb);
  111.             if (_XMLReader.HasValue) {
  112.                 sb.Length = 0;
  113.                 sb.Append("Value : ");
  114.                 sb.Append(_XMLReader.Value);
  115.                 textWriter.WriteLine(sb);
  116.             }
  117.             sb.Length = 0;
  118.             sb.Append("IsEmpty : ");
  119.             sb.Append(_XMLReader.IsEmptyElement);
  120.             textWriter.WriteLine(sb);
  121.             sb.Length = 0;
  122.             sb.Append("Depth : ");
  123.             sb.Append(_XMLReader.Depth);
  124.             textWriter.WriteLine(sb);
  125.             sb.Length = 0;
  126.             sb.Append("AttributeCount: ");
  127.             sb.Append(_XMLReader.AttributeCount);
  128.             textWriter.WriteLine(sb);
  129.             while (_XMLReader.MoveToNextAttribute()) {
  130.                 textWriter.WriteLine(" =========================");
  131.                 sb.Length = 0;
  132.                 sb.Append(" AttributeName: ");
  133.                 sb.Append(_XMLReader.LocalName);
  134.                 textWriter.WriteLine(sb);
  135.                 sb.Length = 0;
  136.                 sb.Append(" Prefix : ");
  137.                 sb.Append(_XMLReader.Prefix);
  138.                 textWriter.WriteLine(sb);
  139.                 sb.Length = 0;
  140.                 sb.Append(" Namespace : ");
  141.                 sb.Append(_XMLReader.NamespaceURI);
  142.                 textWriter.WriteLine(sb);
  143.                 sb.Length = 0;
  144.                 sb.Append(" Value : ");
  145.                 sb.Append(_XMLReader.Value);
  146.                 textWriter.WriteLine(sb);
  147.             }
  148.             _XMLReader.MoveToElement();
  149.            
  150.             return;
  151.         }
  152.        
  153.         // Skips past endtags and non content tags
  154.         private bool SkipXmlElement()
  155.         {
  156.             Util.Log("SdlParser.SkipXmlElement");
  157.             //PrintNode(Console.Out);
  158.             _XMLReader.Skip();
  159.             XmlNodeType nodeType = _XMLReader.MoveToContent();
  160.             while (nodeType == XmlNodeType.EndElement) {
  161.                 _XMLReader.Read();
  162.                 nodeType = _XMLReader.MoveToContent();
  163.                 if (nodeType == XmlNodeType.None)
  164.                     break;
  165.             }
  166.            
  167.             return (nodeType != XmlNodeType.None);
  168.         }
  169.        
  170.         // Reads past endtags and non content tags
  171.         private bool ReadNextXmlElement()
  172.         {
  173.             Util.Log("SdlParser.ReadNextXmlElement");
  174.             _XMLReader.Read();
  175.             XmlNodeType nodeType = _XMLReader.MoveToContent();
  176.             while (nodeType == XmlNodeType.EndElement) {
  177.                 _XMLReader.Read();
  178.                 nodeType = _XMLReader.MoveToContent();
  179.                 if (nodeType == XmlNodeType.None)
  180.                     break;
  181.             }
  182.            
  183.             //PrintNode(Console.Out);
  184.             return (nodeType != XmlNodeType.None);
  185.         }
  186.        
  187.         // Parses complex types
  188.         private URTComplexType ParseComplexType(URTNamespace parsingNamespace, string typeName)
  189.         {
  190.             Util.Log("SdlParser.ParseComplexType NS " + parsingNamespace + " typeName " + typeName);
  191.             // Lookup the name of the type and the base type from which it derives
  192.             if (typeName == null)
  193.                 typeName = LookupAttribute(s_nameString, null, true);
  194.             URTComplexType parsingComplexType = parsingNamespace.LookupComplexType(typeName);
  195.             if (parsingComplexType == null) {
  196.                 parsingComplexType = new URTComplexType(typeName, parsingNamespace.Namespace, parsingNamespace.EncodedNS, _blockDefault, false, typeName != null);
  197.                 parsingNamespace.AddComplexType(parsingComplexType);
  198.             }
  199.             string baseType = LookupAttribute(s_baseString, null, false);
  200.             if (!MatchingStrings(baseType, s_emptyString)) {
  201.                 string baseNS = ParseQName(ref baseType);
  202.                 //if the type exists can this occur twice.
  203.                 parsingComplexType.Extends(baseType, baseNS);
  204.             }
  205.            
  206.             if (parsingComplexType.Fields.Count > 0) {
  207.                 SkipXmlElement();
  208.             }
  209.             else {
  210.                 int curDepth = _XMLReader.Depth;
  211.                 ReadNextXmlElement();
  212.                
  213.                 int fieldNum = 0;
  214.                 string elementName;
  215.                 while (_XMLReader.Depth > curDepth) {
  216.                     elementName = _XMLReader.LocalName;
  217.                     if (MatchingStrings(elementName, s_elementString)) {
  218.                         ParseElementField(parsingNamespace, parsingComplexType, fieldNum);
  219.                         ++fieldNum;
  220.                         continue;
  221.                     }
  222.                     else if (MatchingStrings(elementName, s_attributeString)) {
  223.                         ParseAttributeField(parsingNamespace, parsingComplexType);
  224.                         continue;
  225.                     }
  226.                     else if (MatchingStrings(elementName, s_allString)) {
  227.                         parsingComplexType.BlockType = SchemaBlockType.ALL;
  228.                     }
  229.                     else if (MatchingStrings(elementName, s_sequenceString)) {
  230.                         parsingComplexType.BlockType = SchemaBlockType.SEQUENCE;
  231.                     }
  232.                     else if (MatchingStrings(elementName, s_choiceString)) {
  233.                         parsingComplexType.BlockType = SchemaBlockType.CHOICE;
  234.                     }
  235.                     else {
  236.                         // Ignore others elements such as annotations
  237.                         SkipXmlElement();
  238.                         continue;
  239.                     }
  240.                    
  241.                     // Read next element
  242.                     ReadNextXmlElement();
  243.                 }
  244.             }
  245.            
  246.             return (parsingComplexType);
  247.         }
  248.        
  249.         // Parses simple types
  250.         private URTSimpleType ParseSimpleType(URTNamespace parsingNamespace, string typeName)
  251.         {
  252.             Util.Log("SdlParser.ParseSimpleType NS " + parsingNamespace + " typeName " + typeName);
  253.             // Lookup the name of the type and the base type from which it derives
  254.             if (typeName == null)
  255.                 typeName = LookupAttribute(s_nameString, null, true);
  256.             URTSimpleType parsingSimpleType = parsingNamespace.LookupSimpleType(typeName);
  257.             if (parsingSimpleType == null) {
  258.                 parsingSimpleType = new URTSimpleType(typeName, parsingNamespace.Namespace, parsingNamespace.EncodedNS, typeName != null);
  259.                 string baseType = LookupAttribute(s_baseString, null, false);
  260.                 if (!MatchingStrings(baseType, s_emptyString)) {
  261.                     string baseNS = ParseQName(ref baseType);
  262.                     parsingSimpleType.Extends(baseType, baseNS);
  263.                 }
  264.                 parsingNamespace.AddSimpleType(parsingSimpleType);
  265.                
  266.                 int curDepth = _XMLReader.Depth;
  267.                 ReadNextXmlElement();
  268.                
  269.                 int enumFacetNum = 0;
  270.                 string elementName;
  271.                 while (_XMLReader.Depth > curDepth) {
  272.                     elementName = _XMLReader.LocalName;
  273.                    
  274.                     // The only facet we currently support is enumeration
  275.                     if (MatchingStrings(elementName, s_enumerationString)) {
  276.                         ParseEnumeration(parsingSimpleType, enumFacetNum);
  277.                         ++enumFacetNum;
  278.                     }
  279.                     else if (MatchingStrings(elementName, s_encodingString)) {
  280.                         ParseEncoding(parsingSimpleType);
  281.                     }
  282.                     else {
  283.                         SkipXmlElement();
  284.                     }
  285.                 }
  286.             }
  287.             else {
  288.                 SkipXmlElement();
  289.             }
  290.            
  291.             return (parsingSimpleType);
  292.         }
  293.        
  294.         // Parses encoding
  295.         private void ParseEncoding(URTSimpleType parsingSimpleType)
  296.         {
  297.             Util.Log("SdlParser.ParseEncoding URTSimpleType " + parsingSimpleType);
  298.             if (_XMLReader.IsEmptyElement == true) {
  299.                 // Get the encoding value
  300.                 string valueString = LookupAttribute(s_valueString, null, true);
  301.                 parsingSimpleType.Encoding = valueString;
  302.             }
  303.             else {
  304.                 throw new SUDSParserException(CoreChannel.GetResourceString("Remoting_Suds_EncodingMustBeEmpty"));
  305.             }
  306.            
  307.             ReadNextXmlElement();
  308.             return;
  309.         }
  310.        
  311.         // Parses enumeration
  312.         private void ParseEnumeration(URTSimpleType parsingSimpleType, int enumFacetNum)
  313.         {
  314.             Util.Log("SdlParser.ParseEnumeration facitNum " + enumFacetNum);
  315.             if (_XMLReader.IsEmptyElement == true) {
  316.                 // Get the enum value
  317.                 string valueString = LookupAttribute(s_valueString, null, true);
  318.                
  319.                 parsingSimpleType.IsEnum = true;
  320.                 parsingSimpleType.AddFacet(new EnumFacet(valueString, enumFacetNum));
  321.             }
  322.             else {
  323.                 throw new SUDSParserException(CoreChannel.GetResourceString("Remoting_Suds_EnumMustBeEmpty"));
  324.             }
  325.            
  326.             ReadNextXmlElement();
  327.             return;
  328.         }
  329.        
  330.        
  331.         // Parses element fields
  332.         private void ParseElementField(URTNamespace parsingNamespace, URTComplexType parsingComplexType, int fieldNum)
  333.         {
  334.             Util.Log("SdlParser.ParseElementField NS " + parsingNamespace + " fieldNum " + fieldNum);
  335.             // Determine the field name
  336.             string fieldTypeName;
  337.             string fieldTypeXmlNS;
  338.             string fieldName = LookupAttribute(s_nameString, null, true);
  339.            
  340.             // Look for array bounds
  341.             string minOccurs = LookupAttribute(s_minOccursString, null, false);
  342.             string maxOccurs = LookupAttribute(s_maxOccursString, null, false);
  343.            
  344.             // Check if the field is optional
  345.             bool bOptional = false;
  346.             if (MatchingStrings(minOccurs, s_zeroString))
  347.                 bOptional = true;
  348.            
  349.             // Check if the field is an inline array
  350.             bool bArray = false;
  351.             string arraySize = null;
  352.             if (!MatchingStrings(maxOccurs, s_emptyString) && !MatchingStrings(maxOccurs, s_oneString)) {
  353.                 if (MatchingStrings(maxOccurs, s_unboundedString))
  354.                     arraySize = String.Empty;
  355.                 else
  356.                     arraySize = maxOccurs;
  357.                 bArray = true;
  358.             }
  359.            
  360.             // Handle anonymous types
  361.             bool bEmbedded;
  362.             bool bPrimitive;
  363.             if (_XMLReader.IsEmptyElement == true) {
  364.                 // Non-anonymous type case
  365.                 fieldTypeName = LookupAttribute(s_typeString, null, false);
  366.                
  367.                 // Handle the absense of type attribute (Object case)
  368.                 ResolveTypeAttribute(ref fieldTypeName, out fieldTypeXmlNS, out bEmbedded, out bPrimitive);
  369.                
  370.                 // Read next element
  371.                 ReadNextXmlElement();
  372.             }
  373.             else {
  374.                 // Anonymous type case
  375.                 fieldTypeXmlNS = parsingNamespace.Namespace;
  376.                 fieldTypeName = parsingNamespace.GetNextAnonymousName();
  377.                 bPrimitive = false;
  378.                 bEmbedded = true;
  379.                 int curDepth = _XMLReader.Depth;
  380.                 ReadNextXmlElement();
  381.                
  382.                 // Parse the type
  383.                 string elementName;
  384.                 while (_XMLReader.Depth > curDepth) {
  385.                     elementName = _XMLReader.LocalName;
  386.                     if (MatchingStrings(elementName, s_complexTypeString)) {
  387.                         URTComplexType complexType = ParseComplexType(parsingNamespace, fieldTypeName);
  388.                         if (complexType.IsEmittableFieldType) {
  389.                             fieldTypeXmlNS = complexType.FieldNamespace;
  390.                             fieldTypeName = complexType.FieldName;
  391.                             bPrimitive = complexType.PrimitiveField;
  392.                             parsingNamespace.RemoveComplexType(complexType);
  393.                         }
  394.                     }
  395.                     else if (MatchingStrings(elementName, s_simpleTypeString)) {
  396.                         URTSimpleType simpleType = ParseSimpleType(parsingNamespace, fieldTypeName);
  397.                         if (simpleType.IsEmittableFieldType) {
  398.                             fieldTypeXmlNS = simpleType.FieldNamespace;
  399.                             fieldTypeName = simpleType.FieldName;
  400.                             bPrimitive = simpleType.PrimitiveField;
  401.                             parsingNamespace.RemoveSimpleType(simpleType);
  402.                         }
  403.                     }
  404.                     else {
  405.                         // Ignore others elements such as annotations
  406.                         SkipXmlElement();
  407.                     }
  408.                 }
  409.             }
  410.            
  411.             // Add field to the type being parsed
  412.             parsingComplexType.AddField(new URTField(fieldName, fieldTypeName, fieldTypeXmlNS, this, bPrimitive, bEmbedded, false, bOptional, bArray, arraySize
  413.             ));
  414.             return;
  415.         }
  416.        
  417.         // Parses attribute fields
  418.         private void ParseAttributeField(URTNamespace parsingNamespace, URTComplexType parsingComplexType)
  419.         {
  420.             Util.Log("SdlParser.ParseAttributeField NS " + parsingNamespace);
  421.             // Lookup field name
  422.             string attrTypeName;
  423.             string attrTypeNS;
  424.             string attrName = LookupAttribute(s_nameString, null, true);
  425.            
  426.             // Check if the field is optional
  427.             bool bOptional = false;
  428.             string minOccurs = LookupAttribute(s_minOccursString, null, false);
  429.             if (MatchingStrings(minOccurs, s_zeroString))
  430.                 bOptional = true;
  431.            
  432.             // Handle anonymous types
  433.             bool bEmbedded;
  434.             bool bPrimitive;
  435.             if (_XMLReader.IsEmptyElement == true) {
  436.                 // Non-anonymous type case and type has to present
  437.                 attrTypeName = LookupAttribute(s_typeString, null, true);
  438.                 ResolveTypeAttribute(ref attrTypeName, out attrTypeNS, out bEmbedded, out bPrimitive);
  439.                
  440.                 // Read next element
  441.                 ReadNextXmlElement();
  442.                
  443.                 // Check for xsd:ID type
  444.                 if (MatchingStrings(attrTypeName, s_idString) && MatchingStrings(attrTypeNS, s_schemaNamespaceString)) {
  445.                     parsingComplexType.IsStruct = false;
  446.                     return;
  447.                 }
  448.             }
  449.             else {
  450.                 // Anonymous type case
  451.                 attrTypeNS = parsingNamespace.Namespace;
  452.                 attrTypeName = parsingNamespace.GetNextAnonymousName();
  453.                 bPrimitive = false;
  454.                 bEmbedded = true;
  455.                 int curDepth = _XMLReader.Depth;
  456.                 ReadNextXmlElement();
  457.                
  458.                 // Parse the type
  459.                 string elementName;
  460.                 while (_XMLReader.Depth > curDepth) {
  461.                     elementName = _XMLReader.LocalName;
  462.                     if (MatchingStrings(elementName, s_simpleTypeString)) {
  463.                         URTSimpleType simpleType = ParseSimpleType(parsingNamespace, attrTypeName);
  464.                         if (simpleType.IsEmittableFieldType) {
  465.                             attrTypeNS = simpleType.FieldNamespace;
  466.                             attrTypeName = simpleType.FieldName;
  467.                             bPrimitive = simpleType.PrimitiveField;
  468.                             parsingNamespace.RemoveSimpleType(simpleType);
  469.                         }
  470.                     }
  471.                     else {
  472.                         // Ignore others elements such as annotations
  473.                         SkipXmlElement();
  474.                     }
  475.                 }
  476.             }
  477.            
  478.             // Add field to the type being parsed
  479.             parsingComplexType.AddField(new URTField(attrName, attrTypeName, attrTypeNS, this, bPrimitive, bEmbedded, true, bOptional, false, null
  480.             ));
  481.             return;
  482.         }
  483.        
  484.         // Parses a class
  485.         private void ParseClass(URTNamespace parsingNamespace)
  486.         {
  487.             Util.Log("SdlParser.ParseClass");
  488.             string className = LookupAttribute(s_nameString, null, false);
  489.             bool bUnique = false;
  490.             if ((className == s_emptyString) && (_parsingInput.UniqueType == null)) {
  491.                 className = _parsingInput.Name;
  492.                 bUnique = true;
  493.             }
  494.             URTComplexType parsingComplexType = parsingNamespace.LookupComplexType(className);
  495.             if (parsingComplexType == null) {
  496.                 parsingComplexType = new URTComplexType(className, parsingNamespace.Namespace, parsingNamespace.EncodedNS, _blockDefault, true, false);
  497.                 if (_bWrappedProxy) {
  498.                     parsingComplexType.SUDSType = SUDSType.ClientProxy;
  499.                    
  500.                     if (_parsingInput.Location.Length > 0) {
  501.                         if (parsingComplexType.ConnectURLs == null)
  502.                             parsingComplexType.ConnectURLs = new ArrayList(10);
  503.                         parsingComplexType.ConnectURLs.Add(_parsingInput.Location);
  504.                     }
  505.                 }
  506.                
  507.                 parsingNamespace.AddComplexType(parsingComplexType);
  508.             }
  509.             if (bUnique) {
  510.                 _parsingInput.UniqueType = parsingComplexType;
  511.             }
  512.             if (parsingComplexType.Methods.Count > 0) {
  513.                 SkipXmlElement();
  514.             }
  515.             else {
  516.                 parsingComplexType.IsSUDSType = true;
  517.                 int curDepth = _XMLReader.Depth;
  518.                 ReadNextXmlElement();
  519.                 while (_XMLReader.Depth > curDepth) {
  520.                     if (MatchingNamespace(s_sudsNamespaceString)) {
  521.                         string elmName = _XMLReader.LocalName;
  522.                         if (MatchingStrings(elmName, s_extendsString)) {
  523.                             string nameValue = LookupAttribute(s_nameString, null, true);
  524.                             string nameValueNS = ParseQName(ref nameValue);
  525.                             parsingComplexType.Extends(nameValue, nameValueNS);
  526.                            
  527.                             //Set up extend class so that it is marked as the correct SUDSType
  528.                             URTNamespace extendsNamespace = LookupNamespace(nameValueNS);
  529.                             if (extendsNamespace == null)
  530.                                 extendsNamespace = new URTNamespace(nameValueNS, this);
  531.                            
  532.                             URTComplexType extendsComplexType = extendsNamespace.LookupComplexType(nameValue);
  533.                             if (extendsComplexType == null) {
  534.                                 extendsComplexType = new URTComplexType(nameValue, extendsNamespace.Namespace, extendsNamespace.EncodedNS, _blockDefault, true, false);
  535.                                 extendsNamespace.AddComplexType(extendsComplexType);
  536.                             }
  537.                             else
  538.                                 extendsComplexType.IsSUDSType = true;
  539.                            
  540.                             if (_bWrappedProxy)
  541.                                 extendsComplexType.SUDSType = SUDSType.ClientProxy;
  542.                             else
  543.                                 extendsComplexType.SUDSType = SUDSType.MarshalByRef;
  544.                            
  545.                             // Only top of inheritance hierarchy is marked
  546.                             //parsingComplexType.SUDSType = SUDSType.None;
  547.                            
  548.                         }
  549.                         else if (MatchingStrings(elmName, s_implementsString)) {
  550.                             string nameValue = LookupAttribute(s_nameString, null, true);
  551.                             string nameValueNS = ParseQName(ref nameValue);
  552.                             parsingComplexType.Implements(nameValue, nameValueNS, this);
  553.                         }
  554.                         else if (MatchingStrings(elmName, s_addressesString)) {
  555.                             ParseAddresses(parsingComplexType);
  556.                             continue;
  557.                         }
  558.                         else if (MatchingStrings(elmName, s_requestResponseString)) {
  559.                             ParseRRMethod(parsingComplexType, null);
  560.                             continue;
  561.                         }
  562.                         else if (MatchingStrings(elmName, s_onewayString)) {
  563.                             ParseOnewayMethod(parsingComplexType, null);
  564.                             continue;
  565.                         }
  566.                         else
  567.                             goto SkipXMLNode;
  568.                     }
  569.                     else
  570.                         goto SkipXMLNode;
  571.                    
  572.                     // Read next element
  573.                     ReadNextXmlElement();
  574.                     continue;
  575.                     SkipXMLNode:
  576.                    
  577.                     // Ignore others elements such as annotations
  578.                     SkipXmlElement();
  579.                 }
  580.             }
  581.            
  582.             return;
  583.         }
  584.        
  585.        
  586.         // Parses an interface
  587.         private void ParseInterface(URTNamespace parsingNamespace)
  588.         {
  589.             Util.Log("SdlParser.ParseInterface");
  590.             string intfName = LookupAttribute(s_nameString, null, true);
  591.             URTInterface parsingInterface = parsingNamespace.LookupInterface(intfName);
  592.            
  593.             if (parsingInterface == null) {
  594.                 parsingInterface = new URTInterface(intfName, parsingNamespace.Namespace, parsingNamespace.EncodedNS);
  595.                 parsingNamespace.AddInterface(parsingInterface);
  596.             }
  597.            
  598.             int curDepth = _XMLReader.Depth;
  599.             ReadNextXmlElement();
  600.             while (_XMLReader.Depth > curDepth) {
  601.                 if (MatchingNamespace(s_sudsNamespaceString)) {
  602.                     string elmName = _XMLReader.LocalName;
  603.                     if (MatchingStrings(elmName, s_extendsString)) {
  604.                         string nameValue = LookupAttribute(s_nameString, null, true);
  605.                         string nameValueNS = ParseQName(ref nameValue);
  606.                         parsingInterface.Extends(nameValue, nameValueNS, this);
  607.                         ReadNextXmlElement();
  608.                         continue;
  609.                     }
  610.                     else if (MatchingStrings(elmName, s_requestResponseString)) {
  611.                         ParseRRMethod(null, parsingInterface);
  612.                         continue;
  613.                     }
  614.                     else if (MatchingStrings(elmName, s_onewayString)) {
  615.                         ParseOnewayMethod(null, parsingInterface);
  616.                         continue;
  617.                     }
  618.                 }
  619.                
  620.                 // Ignore others elements such as annotations
  621.                 SkipXmlElement();
  622.             }
  623.            
  624.             return;
  625.         }
  626.        
  627.         // Parses an address
  628.         private void ParseAddresses(URTComplexType parsingComplexType)
  629.         {
  630.             Util.Log("SdlParser.ParseAddress");
  631.             int curDepth = _XMLReader.Depth;
  632.             ReadNextXmlElement();
  633.             while (_XMLReader.Depth > curDepth) {
  634.                 if (MatchingNamespace(s_sudsNamespaceString)) {
  635.                     string elmName = _XMLReader.LocalName;
  636.                     if (MatchingStrings(elmName, s_addressString)) {
  637.                         string uriValue = LookupAttribute(s_uriString, null, true);
  638.                         if (_bWrappedProxy) {
  639.                             parsingComplexType.SUDSType = SUDSType.ClientProxy;
  640.                             if (parsingComplexType.ConnectURLs == null)
  641.                                 parsingComplexType.ConnectURLs = new ArrayList(10);
  642.                             parsingComplexType.ConnectURLs.Add(uriValue);
  643.                         }
  644.                         ReadNextXmlElement();
  645.                         continue;
  646.                     }
  647.                 }
  648.                
  649.                 // Ignore others elements such as annotations
  650.                 SkipXmlElement();
  651.             }
  652.            
  653.             return;
  654.         }
  655.        
  656.         // Parses a request-response method
  657.         private void ParseRRMethod(URTComplexType parsingComplexType, URTInterface parsingInterface)
  658.         {
  659.             Util.Log("SdlParser.ParseRRMethod ns " + _XMLReader.NamespaceURI);
  660.             string methodName = LookupAttribute(s_nameString, null, true);
  661.             string soapAction = null;
  662.             RRMethod parsingMethod = new RRMethod(methodName, soapAction);
  663.             int curDepth = _XMLReader.Depth;
  664.             ReadNextXmlElement();
  665.             while (_XMLReader.Depth > curDepth) {
  666.                 string elmName = _XMLReader.LocalName;
  667.                 if ((MatchingNamespace(s_soapNamespaceString)) && (MatchingStrings(elmName, s_operationString))) {
  668.                     soapAction = LookupAttribute(s_soapActionString, null, false);
  669.                     parsingMethod.SoapAction = soapAction;
  670.                 }
  671.                 else if (MatchingNamespace(s_sudsNamespaceString)) {
  672.                     if (MatchingStrings(elmName, s_requestString)) {
  673.                         string refValue = LookupAttribute(s_refString, null, true);
  674.                         string refNS = ParseQName(ref refValue);
  675.                         parsingMethod.AddRequest(refValue, refNS);
  676.                         ReadNextXmlElement();
  677.                         continue;
  678.                     }
  679.                     else if (MatchingStrings(elmName, s_responseString)) {
  680.                         string refValue = LookupAttribute(s_refString, null, true);
  681.                         string refNS = ParseQName(ref refValue);
  682.                         parsingMethod.AddResponse(refValue, refNS);
  683.                         ReadNextXmlElement();
  684.                         continue;
  685.                     }
  686.                 }
  687.                
  688.                 // Ignore others elements such as annotations
  689.                 SkipXmlElement();
  690.             }
  691.             if (parsingComplexType != null)
  692.                 parsingComplexType.AddMethod(parsingMethod);
  693.             else
  694.                 parsingInterface.AddMethod(parsingMethod);
  695.            
  696.             return;
  697.         }
  698.        
  699.         // Parses a oneway method
  700.         private void ParseOnewayMethod(URTComplexType parsingComplexType, URTInterface parsingInterface)
  701.         {
  702.             Util.Log("SdlParser.ParseOnewayMethod");
  703.             string methodName = LookupAttribute(s_nameString, null, true);
  704.             string soapAction = LookupAttribute(s_soapActionString, null, false);
  705.             OnewayMethod parsingMethod = new OnewayMethod(methodName, soapAction);
  706.             int curDepth = _XMLReader.Depth;
  707.             ReadNextXmlElement();
  708.             while (_XMLReader.Depth > curDepth) {
  709.                 if (MatchingNamespace(s_sudsNamespaceString)) {
  710.                     string elmName = _XMLReader.LocalName;
  711.                     if (MatchingStrings(elmName, s_requestString)) {
  712.                         string refValue = LookupAttribute(s_refString, null, true);
  713.                         string refNS = ParseQName(ref refValue);
  714.                         parsingMethod.AddMessage(refValue, refNS);
  715.                         ReadNextXmlElement();
  716.                         continue;
  717.                     }
  718.                 }
  719.                
  720.                 // Ignore others elements such as annotations
  721.                 SkipXmlElement();
  722.             }
  723.             if (parsingComplexType != null)
  724.                 parsingComplexType.AddMethod(parsingMethod);
  725.             else
  726.                 parsingInterface.AddMethod(parsingMethod);
  727.            
  728.             return;
  729.         }
  730.        
  731.         // Parses a global element declaration
  732.         private void ParseElementDecl(URTNamespace parsingNamespace)
  733.         {
  734.             Util.Log("SdlParser.ParseElementDecl");
  735.             // Obtain element name and its type
  736.             string elmName = LookupAttribute(s_nameString, null, true);
  737.             string elmNS = parsingNamespace.Name;
  738.             string typeName = LookupAttribute(s_typeString, null, false);
  739.            
  740.             // Handle the anonymous types
  741.             string typeNS;
  742.             bool bEmbedded;
  743.             bool bPrimitive;
  744.             if (_XMLReader.IsEmptyElement == true) {
  745.                 // Non-anonymous type case
  746.                 // We cannot assert that the type attribute must have been present
  747.                 // due to the Object/ur-type case
  748.                 ResolveTypeAttribute(ref typeName, out typeNS, out bEmbedded, out bPrimitive);
  749.                
  750.                 // Position to the next element
  751.                 ReadNextXmlElement();
  752.             }
  753.             else {
  754.                 // Anonymous type case
  755.                 typeNS = parsingNamespace.Name;
  756.                 typeName = parsingNamespace.GetNextAnonymousName();
  757.                 bEmbedded = true;
  758.                 bPrimitive = false;
  759.                
  760.                 // Parse the type
  761.                 int curDepth = _XMLReader.Depth;
  762.                 ReadNextXmlElement();
  763.                 string elementName;
  764.                 while (_XMLReader.Depth > curDepth) {
  765.                     elementName = _XMLReader.LocalName;
  766.                     if (MatchingStrings(elementName, s_complexTypeString)) {
  767.                         ParseComplexType(parsingNamespace, typeName);
  768.                     }
  769.                     else if (MatchingStrings(elementName, s_simpleTypeString)) {
  770.                         ParseSimpleType(parsingNamespace, typeName);
  771.                     }
  772.                     else {
  773.                         // Ignore others elements such as annotations
  774.                         SkipXmlElement();
  775.                     }
  776.                 }
  777.             }
  778.            
  779.             // Create a new global element under the current namespace
  780.             parsingNamespace.AddElementDecl(new ElementDecl(elmName, elmNS, typeName, typeNS, bPrimitive));
  781.            
  782.             return;
  783.         }
  784.        
  785.         // Checks for reference and array types and resolves to
  786.         // actual types. It returns true if the type needs [Embedded] attribute
  787.         private void ResolveTypeNames(ref string typeNS, ref string typeName, out bool bEmbedded, out bool bPrimitive)
  788.         {
  789.             Util.Log("SdlParser.ResolveTypeNames typeNS " + typeNS + " typeName " + typeName);
  790.             // Check for reference and array types
  791.             bEmbedded = true;
  792.             bool bArrayType = false;
  793.             if (MatchingStrings(typeNS, s_soapNamespaceString)) {
  794.                 if (MatchingStrings(typeName, s_referenceString))
  795.                     bEmbedded = false;
  796.                 else if (MatchingStrings(typeName, s_arrayString))
  797.                     bArrayType = true;
  798.             }
  799.            
  800.             Util.Log("SdlParser.ResolveTypeNames typeNS 1 bEmbedded " + bEmbedded + " bArrayType " + bArrayType);
  801.             // Resolve to the actual type in the case of reference and array types
  802.             if ((bEmbedded == false) || (bArrayType == true)) {
  803.                 Util.Log("SdlParser.ResolveTypeNames typeNS 2 ");
  804.                 typeName = LookupAttribute(s_refTypeString, s_sudsNamespaceString, true);
  805.                 Util.Log("SdlParser.ResolveTypeNames typeNS 3 typeName " + typeName);
  806.                 typeNS = ParseQName(ref typeName);
  807.             }
  808.            
  809.             // Primitive types do not need the [Embedded] attribute;
  810.             bPrimitive = IsPrimitiveType(typeNS, typeName);
  811.             if (bPrimitive) {
  812.                 typeName = MapSchemaTypesToCSharpTypes(typeName);
  813.                 bEmbedded = false;
  814.             }
  815.             else if (MatchingStrings(typeName, s_urTypeString) && MatchingStrings(typeNS, s_schemaNamespaceString)) {
  816.                 typeName = s_objectString;
  817.             }
  818.            
  819.             return;
  820.         }
  821.        
  822.         // Parses namespace declaration elements
  823.         private URTNamespace ParseNamespace()
  824.         {
  825.             Util.Log("SdlParser.ParseNamespace");
  826.             // Determine the new namespace encountered
  827.             string name = (string)LookupAttribute(s_targetNamespaceString, null, false);
  828.             bool bUnique = false;
  829.             if (MatchingStrings(name, s_emptyString) && MatchingStrings(_XMLReader.LocalName, s_sudsString) && _parsingInput.UniqueNS == null) {
  830.                 name = _parsingInput.TargetNS;
  831.                 bUnique = true;
  832.             }
  833.            
  834.             // Add the namespace being parsed to the list if neccessary
  835.             URTNamespace parsingNamespace = LookupNamespace(name);
  836.             if (parsingNamespace == null) {
  837.                 parsingNamespace = new URTNamespace(name, this);
  838.                 _URTNamespaces.Add(parsingNamespace);
  839.             }
  840.             if (bUnique)
  841.                 _parsingInput.UniqueNS = parsingNamespace;
  842.             //_namespaceStack = NamespaceStack.Push(_namespaceStack, _parsingNamespace, _XMLReader.Depth);
  843.            
  844.             // Parse schema defaults
  845.             //if(MatchingStrings(_XMLReader.LocalName, s_sudsString))
  846.             //{
  847.            
  848.             //}
  849.            
  850.             // Read the next record
  851.             ReadNextXmlElement();
  852.            
  853.             return (parsingNamespace);
  854.         }
  855.        
  856.         private void ParseReaderStreamLocation(ReaderStream reader)
  857.         {
  858.             Util.Log("SdlParser.ParseReaderStreamLocation");
  859.             string location = reader.Location;
  860.             int index = location.IndexOf(':');
  861.             if (index != -1) {
  862.                 string protocol = location.Substring(0, index).ToLower(CultureInfo.InvariantCulture);
  863.                 string value = location.Substring(index + 1);
  864.                 if (protocol == "file") {
  865.                     //Console.WriteLine("Loading file:" + value);
  866.                     reader.InputStream = new StreamReader(value);
  867.                 }
  868.                 else if (protocol.StartsWith("http")) {
  869.                     //Console.WriteLine("Loading " + protocol + ':' + value);
  870.                     /*
  871.                     // Setup proxy settings
  872.                     DefaultControlObject proxyObject = new DefaultControlObject();
  873.                     proxyObject.ProxyNoLocal = true;
  874.                     GlobalProxySelection.Select = proxyObject;
  875.                     */                   
  876. WebRequest request = WebRequest.Create(location);
  877.                     WebResponse response = request.GetResponse();
  878.                     Stream responseStream = response.GetResponseStream();
  879.                     reader.InputStream = new StreamReader(responseStream);
  880.                 }
  881.             }
  882.            
  883.             return;
  884.         }
  885.        
  886.         private void ParseImport()
  887.         {
  888.             Util.Log("SdlParser.ParseImport");
  889.             string ns = LookupAttribute(s_namespaceString, null, true);
  890.             string location = LookupAttribute(s_locationString, null, true);
  891.             ReaderStream reader = ReaderStream.GetReaderStream(_readerStreams, location);
  892.             if (reader.InputStream == null)
  893.                 ParseReaderStreamLocation(reader);
  894.             ReadNextXmlElement();
  895.             return;
  896.         }
  897.        
  898.         internal void Parse()
  899.         {
  900.             Util.Log("SdlParser.Parse");
  901.             XmlNameTable primedNametable = CreatePrimedNametable();
  902.             ReaderStream input = _readerStreams;
  903.             do {
  904.                 // Initialize the parser
  905.                 _XMLReader = new XmlTextReader(input.InputStream, primedNametable);
  906.                 // | XmlReader.NamespaceAttributes;
  907.                 //_XMLReader.Flags &= ~(XmlReader.IgnoreCharacterEntities | XmlReader.TokenView);
  908.                 //_XMLReader.EntityHandling |= EntityHandling.ExpandEntities; set temp for Xml change, needs to be set in XmlTextReader
  909.                 _XMLReader.WhitespaceHandling = WhitespaceHandling.None;
  910.                 //_XMLReader.ValidationCallback = new ValidationDelegate(ValidationCallback);
  911.                 ParseInput(input);
  912.                 input = ReaderStream.GetNextReaderStream(input);
  913.             }
  914.             while (input != null);
  915.            
  916.            
  917.             if (null != _writerStreams) {
  918.                 WriterStream.Close(_writerStreams);
  919.             }
  920.            
  921.             return;
  922.         }
  923.        
  924.         // Starts the parser
  925.         private void ParseInput(ReaderStream input)
  926.         {
  927.             Util.Log("SdlParser.ParseInput");
  928.             _parsingInput = input;
  929.             try {
  930.                 ReadNextXmlElement();
  931.                 string elementName = _XMLReader.LocalName;
  932.                 if (MatchingNamespace(s_serviceNamespaceString) && MatchingStrings(elementName, s_serviceDescString)) {
  933.                     ParseSdl();
  934.                 }
  935.                 else
  936.                     throw new SUDSParserException(CoreChannel.GetResourceString("Remoting_Suds_UnknownElementAtRootLevel"));
  937.             }
  938.             finally {
  939.                 WriterStream.Flush(_writerStreams);
  940.             }
  941.         }
  942.        
  943.         // Parse Sdl
  944.         private void ParseSdl()
  945.         {
  946.             Util.Log("SdlParser.ParseSdl");
  947.             _parsingInput.Name = LookupAttribute(s_nameString, null, false);
  948.             _parsingInput.TargetNS = LookupAttribute(s_targetNamespaceString, null, false);
  949.            
  950.             int curDepth = _XMLReader.Depth;
  951.             ReadNextXmlElement();
  952.             while (_XMLReader.Depth > curDepth) {
  953.                 string elementName = _XMLReader.LocalName;
  954.                 if (MatchingNamespace(s_schemaNamespaceString)) {
  955.                     if (MatchingStrings(elementName, s_schemaString)) {
  956.                         ParseSchema();
  957.                         continue;
  958.                     }
  959.                 }
  960.                 else if (MatchingNamespace(s_sudsNamespaceString)) {
  961.                     if (MatchingStrings(elementName, s_sudsString)) {
  962.                         ParseSUDS();
  963.                         continue;
  964.                     }
  965.                 }
  966.                
  967.                 // Ignore others elements such as annotations
  968.                 SkipXmlElement();
  969.             }
  970.            
  971.             Resolve();
  972.             Util.Log("SdlParser.ParseSdl Invoke PrintCSC");
  973.             PrintCSC();
  974.         }
  975.        
  976.         // Parse Schema
  977.         private void ParseSchema()
  978.         {
  979.             Util.Log("SdlParser.ParseSchema");
  980.             // Remember the current depth
  981.             int curDepth = _XMLReader.Depth;
  982.            
  983.             // Parse the target namespace first
  984.             URTNamespace parsingNamespace = ParseNamespace();
  985.            
  986.             // Parse schema elements
  987.             while (_XMLReader.Depth > curDepth) {
  988.                 string elementName = _XMLReader.LocalName;
  989.                 if (MatchingNamespace(s_schemaNamespaceString)) {
  990.                     if (MatchingStrings(elementName, s_complexTypeString))
  991.                         ParseComplexType(parsingNamespace, null);
  992.                     else if (MatchingStrings(elementName, s_simpleTypeString))
  993.                         ParseSimpleType(parsingNamespace, null);
  994.                     else if (MatchingStrings(elementName, s_schemaString))
  995.                         ParseSchema();
  996.                     else if (MatchingStrings(elementName, s_elementString))
  997.                         ParseElementDecl(parsingNamespace);
  998.                     else if (MatchingStrings(elementName, s_importString))
  999.                         ParseImport();
  1000.                     else
  1001.                         goto SkipXMLNode;
  1002.                    
  1003.                     continue;
  1004.                 }
  1005.                 SkipXMLNode:
  1006.                
  1007.                 // Ignore others elements such as annotations
  1008.                 SkipXmlElement();
  1009.             }
  1010.            
  1011.             return;
  1012.         }
  1013.        
  1014.         // Parse SUDS
  1015.         private void ParseSUDS()
  1016.         {
  1017.             Util.Log("SdlParser.ParseSUDS");
  1018.             // Remember the current depth
  1019.             int curDepth = _XMLReader.Depth;
  1020.            
  1021.             // Parse the target namespace first
  1022.             URTNamespace parsingNamespace = ParseNamespace();
  1023.            
  1024.             // Parse schema elements
  1025.             while (_XMLReader.Depth > curDepth) {
  1026.                 string elementName = _XMLReader.LocalName;
  1027.                 if (MatchingNamespace(s_sudsNamespaceString)) {
  1028.                     if (MatchingStrings(elementName, s_interfaceString))
  1029.                         ParseInterface(parsingNamespace);
  1030.                     else if (MatchingStrings(elementName, s_serviceString))
  1031.                         ParseClass(parsingNamespace);
  1032.                     else if (MatchingStrings(elementName, s_importString))
  1033.                         ParseImport();
  1034.                     else
  1035.                         goto SkipXMLNode;
  1036.                    
  1037.                     continue;
  1038.                 }
  1039.                 else if (MatchingNamespace(s_schemaNamespaceString) && MatchingStrings(elementName, s_schemaString)) {
  1040.                     ParseSchema();
  1041.                     continue;
  1042.                 }
  1043.                 SkipXMLNode:
  1044.                
  1045.                 // Ignore others elements such as annotations
  1046.                 SkipXmlElement();
  1047.             }
  1048.            
  1049.             return;
  1050.         }
  1051.        
  1052.         // Resolves internal references
  1053.         private void Resolve()
  1054.         {
  1055.             Util.Log("SdlParser.Resolve");
  1056.             for (int i = 0; i < _URTNamespaces.Count; i++)
  1057.                 ((URTNamespace)_URTNamespaces[i]).ResolveElements(this);
  1058.            
  1059.             for (int i = 0; i < _URTNamespaces.Count; i++)
  1060.                 ((URTNamespace)_URTNamespaces[i]).ResolveTypes(this);
  1061.            
  1062.             for (int i = 0; i < _URTNamespaces.Count; i++)
  1063.                 ((URTNamespace)_URTNamespaces[i]).ResolveMethods();
  1064.         }
  1065.        
  1066.         // Lookup a given attribute position.
  1067.         // Note that the supplied strings must have been atomized
  1068.         private string LookupAttribute(string attrName, string attrNS, bool throwExp)
  1069.         {
  1070.             string value = s_emptyString;
  1071.             bool bPresent;
  1072.             if (attrNS != null)
  1073.                 bPresent = _XMLReader.MoveToAttribute(attrName, attrNS);
  1074.             else
  1075.                 bPresent = _XMLReader.MoveToAttribute(attrName);
  1076.            
  1077.             if (bPresent)
  1078.                 value = Atomize(_XMLReader.Value.Trim());
  1079.             _XMLReader.MoveToElement();
  1080.            
  1081.             if ((bPresent == false) && (throwExp == true)) {
  1082.                 throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_AttributeNotFound"), attrName));
  1083.             }
  1084.             Util.Log("SdlParser.LookupAttribute " + attrName + "=" + value + ", NS " + attrNS + ", Exp " + throwExp);
  1085.             return (value);
  1086.         }
  1087.        
  1088.         // Resolves type attribute into its constituent parts
  1089.         private void ResolveTypeAttribute(ref string typeName, out string typeNS, out bool bEmbedded, out bool bPrimitive)
  1090.         {
  1091.             Util.Log("SdlParser.ResolveTypeAttribute typeName " + typeName);
  1092.             if (MatchingStrings(typeName, s_emptyString)) {
  1093.                 typeName = s_objectString;
  1094.                 typeNS = s_schemaNamespaceString;
  1095.                 bEmbedded = true;
  1096.                 bPrimitive = false;
  1097.             }
  1098.             else {
  1099.                 // The type field is a QName
  1100.                 typeNS = ParseQName(ref typeName);
  1101.                
  1102.                 // Check for reference and array types
  1103.                 ResolveTypeNames(ref typeNS, ref typeName, out bEmbedded, out bPrimitive);
  1104.             }
  1105.            
  1106.             return;
  1107.         }
  1108.        
  1109.         // Parses a qname
  1110.         private string ParseQName(ref string qname)
  1111.         {
  1112.             Util.Log("SdlParser.ParseQName Enter qname " + qname);
  1113.             int colonIndex = qname.IndexOf(":");
  1114.             if (colonIndex == -1) {
  1115.                 //textWriter.WriteLine("DefaultNS: " + _XMLReader.LookupNamespace(s_emptyString) + '\n' +
  1116.                 // "ElementNS: " + _XMLReader.Namespace);
  1117.                 // Should this be element namespace or default namespace
  1118.                 // For attributes names, element namespace makes more sense
  1119.                 // For QName values, default namespace makes more sense
  1120.                 // I am currently returning default namespace
  1121.                 return (_XMLReader.LookupNamespace(s_emptyString));
  1122.             }
  1123.            
  1124.             // Get the suffix and atmoize it
  1125.             string prefix = qname.Substring(0, colonIndex);
  1126.             qname = Atomize(qname.Substring(colonIndex + 1));
  1127.            
  1128.             string ns = _XMLReader.LookupNamespace(prefix);
  1129.             if (ns == null)
  1130.                 PrintNode(Console.Out);
  1131.             ns = Atomize(ns);
  1132.             Util.Log("SdlParser.ParseQName Exit qname " + qname + " ns " + ns);
  1133.             return (ns);
  1134.         }
  1135.        
  1136.         // Returns true if the type needs to be qualified with namespace
  1137.         private static bool Qualify(string typeNS, string curNS)
  1138.         {
  1139.             Util.Log("SdlParser.Qualify typeNS " + typeNS + " curNS " + curNS);
  1140.             if (MatchingStrings(typeNS, s_schemaNamespaceString) || MatchingStrings(typeNS, s_soapNamespaceString) || MatchingStrings(typeNS, "System") || MatchingStrings(typeNS, curNS))
  1141.                 return (false);
  1142.            
  1143.             return (true);
  1144.         }
  1145.        
  1146.         // Returns true if the current element node namespace has matching namespace
  1147.         private bool MatchingNamespace(string elmNS)
  1148.         {
  1149.             //Util.Log("SdlParser.MathcingNamespace "+elmNS);
  1150.             if (MatchingStrings(_XMLReader.NamespaceURI, elmNS))
  1151.                 // ||
  1152.                 // MatchingStrings(_XMLReader.Prefix, s_emptyString))
  1153.                 return (true);
  1154.            
  1155.             return (false);
  1156.         }
  1157.        
  1158.         // Returns true if the atomized strings match
  1159.         private static bool MatchingStrings(string left, string right)
  1160.         {
  1161.             //Util.Log("SdlParser.MatchingStrings left "+left+" right "+right);
  1162.             return ((object)left == (object)right);
  1163.         }
  1164.        
  1165.         // Atmozie the given string
  1166.         internal string Atomize(string str)
  1167.         {
  1168.             // Always atmoize using the table defined on the
  1169.             // current XML parser
  1170.             return (_XMLReader.NameTable.Add(str));
  1171.         }
  1172.        
  1173.         // Maps URT types to CSharp types
  1174.         private static string MapSchemaTypesToCSharpTypes(string fullTypeName)
  1175.         {
  1176.             Util.Log("SdlParser.MapSchemaTypesToCSharpTypes Enter fullTypeName " + fullTypeName);
  1177.             // Check for array types
  1178.             string typeName = fullTypeName;
  1179.             int index = fullTypeName.IndexOf('[');
  1180.             if (index != -1)
  1181.                 typeName = fullTypeName.Substring(0, index);
  1182.            
  1183.             string newTypeName = typeName;
  1184.             // Handle byte and sbyte
  1185.             if (typeName == "unsigned-byte" || typeName == "binary")
  1186.                 newTypeName = "byte";
  1187.             else if (typeName == "byte")
  1188.                 newTypeName = "sbyte";
  1189.             else if (typeName.StartsWith("unsigned-"))
  1190.                 newTypeName = 'u' + typeName.Substring("unsigned-".Length);
  1191.             else if (typeName == "boolean")
  1192.                 newTypeName = "bool";
  1193.             else if (typeName == "string")
  1194.                 newTypeName = "String";
  1195.             else if (typeName == "character")
  1196.                 newTypeName = "char";
  1197.             else if (typeName == "ur-type")
  1198.                 newTypeName = "Object";
  1199.             else if (typeName == "timeInstant")
  1200.                 // Handle unsigned versions
  1201.                 // short, int, long, float, double, decimal are the same
  1202.                 // Handle bool type
  1203.                 // Schemas have not yet defined char type
  1204.                 newTypeName = "DateTime";
  1205.            
  1206.             // Handle array types
  1207.             if (index != -1)
  1208.                 newTypeName = newTypeName + fullTypeName.Substring(index);
  1209.             Util.Log("SdlParser.MapSchemaTypesToCSharpTypes Exit Type " + newTypeName);
  1210.             return (newTypeName);
  1211.         }
  1212.        
  1213.         // Return true if the given type is a primitive type
  1214.         private static bool IsPrimitiveType(string typeNS, string typeName)
  1215.         {
  1216.             Util.Log("SdlParser.IsPrimitiveType typeNS " + typeNS + " typeName " + typeName);
  1217.             bool fReturn = false;
  1218.             if (MatchingStrings(typeNS, s_schemaNamespaceString)) {
  1219.                 if (!MatchingStrings(typeName, s_urTypeString))
  1220.                     fReturn = true;
  1221.             }
  1222.            
  1223.             return (fReturn);
  1224.         }
  1225.        
  1226.         // Looks up a matching namespace
  1227.         private URTNamespace LookupNamespace(string name)
  1228.         {
  1229.             //Util.Log("SdlParser.lookupNamespace name "+name);
  1230.             for (int i = 0; i < _URTNamespaces.Count; i++) {
  1231.                 URTNamespace urtNS = (URTNamespace)_URTNamespaces[i];
  1232.                 if (SdlParser.MatchingStrings(urtNS.Name, name))
  1233.                     return (urtNS);
  1234.             }
  1235.            
  1236.             return (null);
  1237.         }
  1238.        
  1239.         // Prints the parsed entities
  1240.         private void PrintCSC()
  1241.         {
  1242.             Util.Log("SdlParser.PrintCSC ");
  1243.             for (int i = 0; i < _URTNamespaces.Count; i++) {
  1244.                 URTNamespace urtNS = (URTNamespace)_URTNamespaces[i];
  1245.                 if ((urtNS.IsEmpty == false) && (urtNS.UrtType != UrtType.UrtSystem)) {
  1246.                     string fileName = urtNS.IsURTNamespace ? urtNS.AssemName : urtNS.EncodedNS;
  1247.                     Util.Log("SdlParser.PrintCSC fileName " + fileName + " " + urtNS.Namespace);
  1248.                     string completeFileName = "";
  1249.                    
  1250.                     WriterStream output = WriterStream.GetWriterStream(ref _writerStreams, _outputDir, fileName, ref completeFileName);
  1251.                     if (completeFileName.Length > 0)
  1252.                         _outCodeStreamList.Add(completeFileName);
  1253.                     urtNS.PrintCSC(output.OutputStream);
  1254.                 }
  1255.             }
  1256.             return;
  1257.         }
  1258.        
  1259.         internal UrtType IsURTExportedType(string name, out string ns, out string assemName)
  1260.         {
  1261.             Util.Log("SdlParser.IsURTExportedType Enter " + name);
  1262.             //Console.WriteLine("Parsing " + name);
  1263.             UrtType urtType = UrtType.None;
  1264.             ns = null;
  1265.             assemName = null;
  1266.             if (SoapServices.IsClrTypeNamespace(name)) {
  1267.                 SoapServices.DecodeXmlNamespaceForClrTypeNamespace(name, out ns, out assemName);
  1268.                 if (assemName == null) {
  1269.                     assemName = typeof(string).Assembly.GetName().Name;
  1270.                     urtType = UrtType.UrtSystem;
  1271.                 }
  1272.                 else
  1273.                     urtType = UrtType.UrtUser;
  1274.             }
  1275.             if (urtType == UrtType.None) {
  1276.                 ns = name;
  1277.                 assemName = ns;
  1278.                 if (NeedsEncoding(name))
  1279.                     urtType = UrtType.Interop;
  1280.             }
  1281.            
  1282.             ns = Atomize(ns);
  1283.             assemName = Atomize(assemName);
  1284.            
  1285.             //Console.WriteLine("NS: " + ns + " Assembly: " + assemName);
  1286.             Util.Log("SdlParser.IsURTExportedType Exit " + ((Enum)urtType).ToString());
  1287.             return (urtType);
  1288.         }
  1289.        
  1290.         private static bool NeedsEncoding(string ns)
  1291.         {
  1292.             bool bEncode = false;
  1293.             if (MatchingStrings(ns, s_schemaNamespaceString) || MatchingStrings(ns, s_instanceNamespaceString) || MatchingStrings(ns, s_soapNamespaceString) || MatchingStrings(ns, s_sudsNamespaceString) || MatchingStrings(ns, s_serviceNamespaceString))
  1294.                 bEncode = false;
  1295.             else
  1296.                 bEncode = true;
  1297.            
  1298.             Util.Log("SdlParser.NeedsEncoding ns " + ns + " " + bEncode);
  1299.             return bEncode;
  1300.         }
  1301.        
  1302.         // Finalizer
  1303. /*protected override void Finalize()
  1304.         {
  1305.             Interlocked.Decrement(ref s_counter);
  1306.             return;
  1307.         }
  1308.         // Timer callback
  1309.         private static void Cleanup(Object state)
  1310.         {
  1311.             // Check if there are existing instances using the nametable
  1312.             if(s_counter == 0)
  1313.             {
  1314.                 // Null the name table so that it can get garbage collected
  1315.                 Object table = s_atomizedTable;
  1316.                 s_atomizedTable = null;
  1317.                 // Check for new instances
  1318.                 if(s_counter > 0)
  1319.                 {
  1320.                     // A new instance got created and it might be using the
  1321.                     // name table that we hold now. Update the satic if that
  1322.                     // was indeed the case
  1323.                     Interlocked.CompareExchange(ref s_atomizedTable, table, null);
  1324.                 }
  1325.             }
  1326.             return;
  1327.         }*/       
  1328.        
  1329.         // Creates and initializes the name table if neccessary
  1330.         private static XmlNameTable CreatePrimedNametable()
  1331.         {
  1332.             Util.Log("SdlParser.CreatePrimedNametable");
  1333.            
  1334.             //Interlocked.Increment(ref s_counter);
  1335.             /*if(s_atomizedTable == null)
  1336.             {
  1337.                 // Create a new nametable
  1338.                 //MTNameTable newTable = new MTNameTable(true);
  1339.             }*/           
  1340. NameTable newTable = new NameTable();
  1341.            
  1342.             // Atomically update static location to point to the current table
  1343.             /*Object oldTable = Interlocked.CompareExchange(ref s_atomizedTable, newTable, null);
  1344.                 if(oldTable != null)
  1345.                     newTable = (MTNameTable) oldTable; */           
  1346.            
  1347.             // Atomize frequently used strings for perf
  1348.             // The following ops are not done inside a lock as they are idempotent
  1349. s_operationString = newTable.Add("operation");
  1350.             s_emptyString = newTable.Add(String.Empty);
  1351.             s_complexTypeString = newTable.Add("complexType");
  1352.             s_simpleTypeString = newTable.Add("simpleType");
  1353.             s_elementString = newTable.Add("element");
  1354.             s_enumerationString = newTable.Add("enumeration");
  1355.             s_encodingString = newTable.Add("encoding");
  1356.             s_attributeString = newTable.Add("attribute");
  1357.             s_allString = newTable.Add("all");
  1358.             s_sequenceString = newTable.Add("sequence");
  1359.             s_choiceString = newTable.Add("choice");
  1360.             s_minOccursString = newTable.Add("minOccurs");
  1361.             s_maxOccursString = newTable.Add("maxOccurs");
  1362.             s_unboundedString = newTable.Add("unbounded");
  1363.             s_oneString = newTable.Add("1");
  1364.             s_zeroString = newTable.Add("0");
  1365.             s_nameString = newTable.Add("name");
  1366.             s_typeString = newTable.Add("type");
  1367.             s_baseString = newTable.Add("base");
  1368.             s_valueString = newTable.Add("value");
  1369.             s_interfaceString = newTable.Add("interface");
  1370.             s_serviceString = newTable.Add("service");
  1371.             s_extendsString = newTable.Add("extends");
  1372.             s_addressesString = newTable.Add("addresses");
  1373.             s_addressString = newTable.Add("address");
  1374.             s_uriString = newTable.Add("uri");
  1375.             s_implementsString = newTable.Add("implements");
  1376.             s_requestString = newTable.Add("request");
  1377.             s_responseString = newTable.Add("response");
  1378.             s_requestResponseString = newTable.Add("requestResponse");
  1379.             s_messageString = newTable.Add("message");
  1380.             s_locationString = newTable.Add("location");
  1381.             s_importString = newTable.Add("import");
  1382.             s_onewayString = newTable.Add("oneway");
  1383.             s_refString = newTable.Add("ref");
  1384.             s_refTypeString = newTable.Add("refType");
  1385.             s_referenceString = newTable.Add("Reference");
  1386.             s_objectString = newTable.Add("Object");
  1387.             s_urTypeString = newTable.Add("ur-type");
  1388.             s_arrayString = newTable.Add("Array");
  1389.             //s_sudsString = newTable.Add("suds");
  1390.             s_sudsString = newTable.Add("soap");
  1391.             s_soapString = newTable.Add("soap");
  1392.             s_serviceDescString = newTable.Add("serviceDescription");
  1393.             s_schemaString = newTable.Add("schema");
  1394.             s_targetNamespaceString = newTable.Add("targetNamespace");
  1395.             s_namespaceString = newTable.Add("namespace");
  1396.             s_idString = newTable.Add("ID");
  1397.             s_soapActionString = newTable.Add("soapAction");
  1398.             s_schemaNamespaceString = newTable.Add("http://www.w3.org/2000/10/XMLSchema");
  1399.             s_instanceNamespaceString = newTable.Add("http://www.w3.org/2000/10/XMLSchema-instance");
  1400.             s_soapNamespaceString = newTable.Add("urn:schemas-xmlsoap-org:soap.v1");
  1401.             //s_sudsNamespaceString = newTable.Add("urn:schemas-xmlsoap-org:suds.v1");
  1402.             s_sudsNamespaceString = newTable.Add("urn:schemas-xmlsoap-org:soap-sdl-2000-01-25");
  1403.             //s_URTNamespaceString = newTable.Add("urn:schamas-xmlsoap-org:urt.v1");
  1404.             //s_serviceNamespaceString = newTable.Add("urn:schemas-xmlsoap-org:servicedesc.v1");
  1405.             s_serviceNamespaceString = newTable.Add("urn:schemas-xmlsoap-org:sdl.2000-01-25");
  1406.            
  1407.             return ((XmlNameTable)newTable);
  1408.            
  1409.             // Enqueue a timer if it has not already been done
  1410.             /*Timer timer = new Timer(new TimerCallback(Cleanup), null, 1000, 1000);
  1411.                 Object existingTimer = Interlocked.CompareExchange(ref s_enqueuedTimer, timer, null);
  1412.                 if(existingTimer != null)
  1413.                     timer.Dispose(); */           
  1414.             //}
  1415.            
  1416.             //return((XmlNameTable) s_atomizedTable);
  1417.         }
  1418.        
  1419.         // Private fields
  1420.         private XmlTextReader _XMLReader;
  1421.         private ArrayList _URTNamespaces;
  1422.         private ReaderStream _parsingInput;
  1423.         private bool _bWrappedProxy;
  1424.         private ReaderStream _readerStreams;
  1425.         private string _outputDir;
  1426.         private ArrayList _outCodeStreamList;
  1427.         private WriterStream _writerStreams;
  1428.         private SchemaBlockType _blockDefault;
  1429.        
  1430.         //static private Object s_atomizedTable = null;
  1431.         //static private int s_counter = 0;
  1432.         //static private Object s_enqueuedTimer = null;
  1433.         private static string s_operationString;
  1434.         private static string s_emptyString;
  1435.         private static string s_complexTypeString;
  1436.         private static string s_simpleTypeString;
  1437.         private static string s_elementString;
  1438.         private static string s_enumerationString;
  1439.         private static string s_encodingString;
  1440.         private static string s_attributeString;
  1441.         private static string s_allString;
  1442.         private static string s_sequenceString;
  1443.         private static string s_choiceString;
  1444.         private static string s_minOccursString;
  1445.         private static string s_maxOccursString;
  1446.         private static string s_unboundedString;
  1447.         private static string s_oneString;
  1448.         private static string s_zeroString;
  1449.         private static string s_nameString;
  1450.         private static string s_typeString;
  1451.         private static string s_baseString;
  1452.         private static string s_valueString;
  1453.         private static string s_interfaceString;
  1454.         private static string s_serviceString;
  1455.         private static string s_extendsString;
  1456.         private static string s_addressesString;
  1457.         private static string s_addressString;
  1458.         private static string s_uriString;
  1459.         private static string s_implementsString;
  1460.         private static string s_requestString;
  1461.         private static string s_responseString;
  1462.         private static string s_requestResponseString;
  1463.         private static string s_messageString;
  1464.         private static string s_locationString;
  1465.         private static string s_importString;
  1466.         private static string s_onewayString;
  1467.         private static string s_refString;
  1468.         private static string s_refTypeString;
  1469.         private static string s_referenceString;
  1470.         private static string s_arrayString;
  1471.         private static string s_objectString;
  1472.         private static string s_urTypeString;
  1473.         private static string s_sudsString;
  1474.         private static string s_soapString;
  1475.         private static string s_serviceDescString;
  1476.         private static string s_schemaString;
  1477.         private static string s_targetNamespaceString;
  1478.         private static string s_namespaceString;
  1479.         private static string s_idString;
  1480.         private static string s_soapActionString;
  1481.         private static string s_instanceNamespaceString;
  1482.         private static string s_schemaNamespaceString;
  1483.         private static string s_soapNamespaceString;
  1484.         private static string s_sudsNamespaceString;
  1485.         private static string s_serviceNamespaceString;
  1486.        
  1487.        
  1488.        
  1489. /***************************************************************
  1490.         **
  1491.         ** Private classes used by SUDS Parser
  1492.         **
  1493.         ***************************************************************/       
  1494.         // Input streams
  1495.         internal class ReaderStream
  1496.         {
  1497.             internal ReaderStream(string location)
  1498.             {
  1499.                 Util.Log("ReaderStream.ReaderStream " + location);
  1500.                 _location = location;
  1501.                 _name = String.Empty;
  1502.                 _targetNS = String.Empty;
  1503.                 _uniqueType = null;
  1504.                 _uniqueNS = null;
  1505.                 _reader = null;
  1506.                 _next = null;
  1507.             }
  1508.             internal string Location {
  1509.                 get { return (_location); }
  1510.             }
  1511.             internal string Name {
  1512.                 get { return (_name); }
  1513.                 set { _name = value; }
  1514.             }
  1515.             internal string TargetNS {
  1516.                 get { return (_targetNS); }
  1517.                 set { _targetNS = value; }
  1518.             }
  1519.             internal URTComplexType UniqueType {
  1520.                 get { return (_uniqueType); }
  1521.                 set { _uniqueType = value; }
  1522.             }
  1523.             internal URTNamespace UniqueNS {
  1524.                 get { return (_uniqueNS); }
  1525.                 set { _uniqueNS = value; }
  1526.             }
  1527.             internal TextReader InputStream {
  1528.                 get { return (_reader); }
  1529.                 set { _reader = value; }
  1530.             }
  1531.             static internal ReaderStream GetReaderStream(ReaderStream inputStreams, string location)
  1532.             {
  1533.                 Util.Log("ReaderStream.GetReaderStream " + location);
  1534.                 ReaderStream input = inputStreams;
  1535.                 ReaderStream last;
  1536.                 do {
  1537.                     if (input._location == location)
  1538.                         return (input);
  1539.                     last = input;
  1540.                     input = input._next;
  1541.                 }
  1542.                 while (input != null);
  1543.                
  1544.                 input = new ReaderStream(location);
  1545.                 last._next = input;
  1546.                
  1547.                 return (input);
  1548.             }
  1549.             static internal ReaderStream GetNextReaderStream(ReaderStream input)
  1550.             {
  1551.                 Util.Log("ReaderStream.GetNextReaderStream ");
  1552.                 return (input._next);
  1553.             }
  1554.            
  1555.             private string _location;
  1556.             private string _name;
  1557.             private string _targetNS;
  1558.             private URTComplexType _uniqueType;
  1559.             private URTNamespace _uniqueNS;
  1560.             private TextReader _reader;
  1561.             private ReaderStream _next;
  1562.         }
  1563.        
  1564.         internal class WriterStream
  1565.         {
  1566.            
  1567.             private WriterStream(string fileName, TextWriter writer)
  1568.             {
  1569.                 Util.Log("WriterStream.WriterStream " + fileName);
  1570.                 _fileName = fileName;
  1571.                 _writer = writer;
  1572.             }
  1573.             internal TextWriter OutputStream {
  1574.                 get { return (_writer); }
  1575.             }
  1576.             static internal void Flush(WriterStream writerStream)
  1577.             {
  1578.                 while (writerStream != null) {
  1579.                     writerStream._writer.Flush();
  1580.                     writerStream = writerStream._next;
  1581.                 }
  1582.                
  1583.                 return;
  1584.             }
  1585.             static internal WriterStream GetWriterStream(ref WriterStream outputStreams, string outputDir, string fileName, ref string completeFileName)
  1586.             {
  1587.                 Util.Log("WriterStream.GetWriterStream " + fileName);
  1588.                 WriterStream output = outputStreams;
  1589.                 while (output != null) {
  1590.                     if (output._fileName == fileName)
  1591.                         return (output);
  1592.                     output = output._next;
  1593.                 }
  1594.                
  1595.                 string diskFileName = fileName;
  1596.                 if (diskFileName.EndsWith(".exe") || diskFileName.EndsWith(".dll"))
  1597.                     diskFileName = diskFileName.Substring(0, diskFileName.Length - 4);
  1598.                 string _completeFileName = outputDir + diskFileName + ".cs";
  1599.                 completeFileName = _completeFileName;
  1600.                 //TextWriter textWriter = new StreamWriter(outputDir + fileName + ".cs", false);
  1601.                 TextWriter textWriter = new StreamWriter(_completeFileName, false, new UTF8Encoding(false));
  1602.                 output = new WriterStream(fileName, textWriter);
  1603.                 output._next = outputStreams;
  1604.                 outputStreams = output;
  1605.                 Util.Log("WriterStream.GetWriterStream in fileName " + fileName + " completeFileName " + _completeFileName);
  1606.                 return (output);
  1607.             }
  1608.            
  1609.             static internal void Close(WriterStream outputStreams)
  1610.             {
  1611.                 WriterStream output = outputStreams;
  1612.                 while (output != null) {
  1613.                     output._writer.Close();
  1614.                     output = output._next;
  1615.                 }
  1616.             }
  1617.            
  1618.             private string _fileName;
  1619.             private TextWriter _writer;
  1620.             private WriterStream _next;
  1621.         }
  1622.        
  1623.         // Represents a parameter of a method
  1624.         [Serializable()]
  1625.         internal enum URTParamType
  1626.         {
  1627.             IN,
  1628.             OUT,
  1629.             REF
  1630.         }
  1631.         internal class URTParam
  1632.         {
  1633.             internal URTParam(string name, string typeName, string typeNS, string encodedNS, URTParamType pType, bool bEmbedded)
  1634.             {
  1635.                 Util.Log("URTParam.URTParam name " + name + " typeName " + typeName + " typeNS " + typeNS + " ecodedNS " + encodedNS + " pType " + pType + " bEmbedded " + bEmbedded);
  1636.                 _name = name;
  1637.                 _typeName = typeName;
  1638.                 _typeNS = typeNS;
  1639.                 _encodedNS = encodedNS;
  1640.                 _pType = pType;
  1641.                 _embeddedParam = bEmbedded;
  1642.             }
  1643.             public override bool Equals(object obj)
  1644.             {
  1645.                 //Util.Log("URTParam.Equals ");
  1646.                 URTParam suppliedParam = (URTParam)obj;
  1647.                 if (_pType == suppliedParam._pType && SdlParser.MatchingStrings(_typeName, suppliedParam._typeName) && SdlParser.MatchingStrings(_typeNS, suppliedParam._typeNS))
  1648.                     return (true);
  1649.                
  1650.                 return (false);
  1651.             }
  1652.            
  1653.            
  1654.             public override int GetHashCode()
  1655.             {
  1656.                 return base.GetHashCode();
  1657.             }
  1658.             internal bool IsCompatibleType(ParameterInfo pInfo)
  1659.             {
  1660.                 Util.Log("URTParam.IsCompatibleType");
  1661.                 if (_pType == URTParamType.OUT) {
  1662.                     if (pInfo.IsOut == false)
  1663.                         return (false);
  1664.                 }
  1665.                
  1666.                 Type parameterType = pInfo.ParameterType;
  1667.                 if (parameterType.Namespace == _typeNS) {
  1668.                     string typeName = _typeName;
  1669.                     if (_pType == URTParamType.REF) {
  1670.                         if (parameterType.IsByRef == false)
  1671.                             return (false);
  1672.                        
  1673.                         typeName = typeName + '&';
  1674.                     }
  1675.                     if (parameterType.Name == typeName)
  1676.                         return (true);
  1677.                 }
  1678.                
  1679.                 return (false);
  1680.             }
  1681.             internal URTParamType ParamType {
  1682.                 get { return (_pType); }
  1683.                 set { _pType = value; }
  1684.             }
  1685.             internal string Name {
  1686.                 get { return (_name); }
  1687.             }
  1688.             internal string TypeName {
  1689.                 get { return (_typeName); }
  1690.             }
  1691.             internal string TypeNS {
  1692.                 get { return (_typeNS); }
  1693.             }
  1694.            
  1695.             internal bool IsInteropType {
  1696.                 get { return ((object)_typeNS != (object)_encodedNS); }
  1697.             }
  1698.            
  1699.             internal string GetTypeString(string curNS)
  1700.             {
  1701.                 Util.Log("URTParam.GetTypeString Enter curNS " + curNS);
  1702.                 string type;
  1703.                 if (SdlParser.Qualify(_typeNS, curNS)) {
  1704.                     StringBuilder sb = new StringBuilder(_encodedNS, 50);
  1705.                     sb.Append('.');
  1706.                     type = sb.Append(_typeName).ToString();
  1707.                 }
  1708.                 else
  1709.                     type = _typeName;
  1710.                
  1711.                 Util.Log("URTParam.GetTypeString Exit type " + type);
  1712.                 return (type);
  1713.             }
  1714.             internal void PrintCSC(StringBuilder sb, string curNS)
  1715.             {
  1716.                 Util.Log("URTParam.PrintCSC curNS " + curNS + " name " + _name);
  1717.                 //if(_embeddedParam)
  1718.                 // sb.Append("[Embedded] ");
  1719.                 sb.Append(PTypeString[(int)_pType]);
  1720.                 sb.Append(GetTypeString(curNS));
  1721.                 sb.Append(' ');
  1722.                 sb.Append(_name);
  1723.                 return;
  1724.             }
  1725.             internal void PrintCSC(StringBuilder sb)
  1726.             {
  1727.                 Util.Log("URTParam.PrintCSC name " + _name);
  1728.                 sb.Append(PTypeString[(int)_pType]);
  1729.                 sb.Append(_name);
  1730.                 return;
  1731.             }
  1732.            
  1733.             private static string[] PTypeString = {"", "out ", "ref "};
  1734.             private string _name;
  1735.             private string _typeName;
  1736.             private string _typeNS;
  1737.             private string _encodedNS;
  1738.             private URTParamType _pType;
  1739.             private bool _embeddedParam;
  1740.         }
  1741.        
  1742.         // Represents a method
  1743.         internal abstract class URTMethod
  1744.         {
  1745.             internal URTMethod(string name, string soapAction)
  1746.             {
  1747.                 Util.Log("URTMethod.URTMethod name " + name + " soapAction " + soapAction);
  1748.                 _methodName = name;
  1749.                 _soapAction = soapAction;
  1750.                 _methodType = null;
  1751.                 _methodFlags = 0;
  1752.                 _params = new ArrayList();
  1753.             }
  1754.             internal string Name {
  1755.                 get { return (_methodName); }
  1756.             }
  1757.             internal string SoapAction {
  1758.                 get { return (_soapAction); }
  1759.                 set { _soapAction = value; }
  1760.             }
  1761.             internal int MethodFlags {
  1762.                 get { return (_methodFlags); }
  1763.                 set { _methodFlags = value; }
  1764.             }
  1765.            
  1766.             internal bool IsInteropType {
  1767.                 get {
  1768.                     if (_methodType != null)
  1769.                         return _methodType.IsInteropType;
  1770.                     else
  1771.                         return false;
  1772.                 }
  1773.             }
  1774.            
  1775.             internal string GetTypeString(string curNS)
  1776.             {
  1777.                 Util.Log("URTMethod.GetTypeString curNS " + curNS);
  1778.                 return ((_methodType != null) ? _methodType.GetTypeString(curNS) : "void");
  1779.             }
  1780.             protected URTParam MethodType {
  1781.                 get { return (_methodType); }
  1782.             }
  1783.             public override int GetHashCode()
  1784.             {
  1785.                 return base.GetHashCode();
  1786.             }
  1787.             public override bool Equals(object obj)
  1788.             {
  1789.                 URTMethod suppliedMethod = (URTMethod)obj;
  1790.                 if (SdlParser.MatchingStrings(_methodName, suppliedMethod._methodName) && _params.Count == suppliedMethod._params.Count) {
  1791.                     for (int i = 0; i < _params.Count; i++) {
  1792.                         if (_params[i].Equals(suppliedMethod._params[i]) == false)
  1793.                             return (false);
  1794.                     }
  1795.                    
  1796.                     return (true);
  1797.                 }
  1798.                
  1799.                 return (false);
  1800.             }
  1801.             internal int GetMethodFlags(MethodInfo method)
  1802.             {
  1803.                 int methodFlags = 0;
  1804.                 MethodAttributes attributes = method.Attributes;
  1805.                 MethodAttributes access = MethodAttributes.Family | MethodAttributes.FamORAssem | MethodAttributes.Public;
  1806.                 if ((attributes & access) == MethodAttributes.Family | (attributes & access) == MethodAttributes.FamORAssem | (attributes & access) == MethodAttributes.Public) {
  1807.                     if (method.Name == _methodName) {
  1808.                         ParameterInfo[] parameters = method.GetParameters();
  1809.                         if (parameters.Length == _params.Count) {
  1810.                             for (int i = 0; i < parameters.Length; i++) {
  1811.                                 if (((URTParam)_params[i]).IsCompatibleType(parameters[i]) == false)
  1812.                                     return (methodFlags);
  1813.                             }
  1814.                            
  1815.                             if ((attributes & access) == MethodAttributes.Family | (attributes & access) == MethodAttributes.FamORAssem)
  1816.                                 methodFlags |= 2;
  1817.                             if ((attributes & MethodAttributes.Virtual) != 0)
  1818.                                 methodFlags |= 4;
  1819.                         }
  1820.                     }
  1821.                 }
  1822.                
  1823.                 return (methodFlags);
  1824.             }
  1825.             internal void AddParam(URTParam newParam)
  1826.             {
  1827.                 Util.Log("URTMethod.AddParam " + newParam.Name);
  1828.                 for (int i = 0; i < _params.Count; i++) {
  1829.                     URTParam extParam = (URTParam)_params[i];
  1830.                     if (SdlParser.MatchingStrings(extParam.Name, newParam.Name)) {
  1831.                         if (extParam.ParamType == URTParamType.IN && newParam.ParamType == URTParamType.OUT && SdlParser.MatchingStrings(extParam.TypeName, newParam.TypeName) && SdlParser.MatchingStrings(extParam.TypeNS, newParam.TypeNS)) {
  1832.                             extParam.ParamType = URTParamType.REF;
  1833.                             return;
  1834.                         }
  1835.                        
  1836.                         throw new SUDSParserException(CoreChannel.GetResourceString("Remoting_Suds_DuplicateParameter"));
  1837.                     }
  1838.                 }
  1839.                
  1840.                 if ((_methodType == null) && (newParam.ParamType == URTParamType.OUT)) {
  1841.                     _methodType = newParam;
  1842.                     return;
  1843.                 }
  1844.                
  1845.                 _params.Add(newParam);
  1846.                 return;
  1847.             }
  1848.             internal void PrintSignature(StringBuilder sb, string curNS)
  1849.             {
  1850.                 Util.Log("URTMethod.PrintSignature curNS " + curNS);
  1851.                 for (int i = 0; i < _params.Count; i++) {
  1852.                     if (i != 0)
  1853.                         sb.Append(", ");
  1854.                     Util.Log("URTMethod.PrintSignature Invoke _params PrintCSC");
  1855.                     ((URTParam)_params[i]).PrintCSC(sb, curNS);
  1856.                 }
  1857.                
  1858.                 return;
  1859.             }
  1860.             internal abstract void PrintCSC(TextWriter textWriter, string indentation, string namePrefix, string curNS, bool bPrintBody, bool bURTType, string bodyPrefix, StringBuilder sb);
  1861.            
  1862.             protected void PrintCSC(TextWriter textWriter, string indentation, string namePrefix, string curNS, bool bPrintBody, string bodyPrefix, StringBuilder sb)
  1863.             {
  1864.                 Util.Log("URTMethod.PrintCSC name " + _methodName + " namePrefix " + namePrefix + " curNS " + curNS + " bPrintBody " + bPrintBody + " bodyPrefix " + bodyPrefix);
  1865.                 // Custom Attributes
  1866.                
  1867.                 /*
  1868.                 if (!fromSubclass)
  1869.                 {
  1870.                     bool bSoapAction = false;
  1871.                     String soapAction = SoapAction;
  1872.                     if ((soapAction != null) && (soapAction.Length > 0))
  1873.                         bSoapAction = true;
  1874.                     if (IsInteropType || bSoapAction)
  1875.                     {
  1876.                         sb.Length = 0;
  1877.                         sb.Append(indentation);
  1878.                         sb.Append("[SoapMethod(");
  1879.                         if (bSoapAction)
  1880.                         {
  1881.                             sb.Append("SoapAction=\"");
  1882.                             sb.Append(soapAction);
  1883.                             sb.Append("\"");
  1884.                         }
  1885.                         if (IsInteropType)
  1886.                         {
  1887.                             if (bSoapAction)
  1888.                             {
  1889.                                 sb.Append(",");
  1890.                             }
  1891.                             sb.Append(", ReturnXmlElementName=\"");
  1892.                             sb.Append(MethodType.Name);
  1893.                             sb.Append(",XmlNamespace=\"");
  1894.                             sb.Append(_methodType.TypeNS);
  1895.                             sb.Append("\", ResponseXmlNamespace=\"");
  1896.                             sb.Append(_methodType.TypeNS);
  1897.                             sb.Append("\"");
  1898.                         }
  1899.                         sb.Append(")]");
  1900.                         textWriter.WriteLine(sb);
  1901.                     }
  1902.                 }
  1903.                 */               
  1904.                
  1905.                 // Check for class methods
  1906. sb.Length = 0;
  1907.                 sb.Append(indentation);
  1908.                 if (_methodFlags != 0) {
  1909.                     if ((_methodFlags & 2) != 0)
  1910.                         sb.Append("protected ");
  1911.                     else
  1912.                         sb.Append("public ");
  1913.                     if ((_methodFlags & 4) != 0)
  1914.                         sb.Append("override ");
  1915.                 }
  1916.                
  1917.                 sb.Append(GetTypeString(curNS));
  1918.                 sb.Append(namePrefix);
  1919.                 sb.Append(_methodName);
  1920.                 sb.Append('(');
  1921.                 if (_params.Count > 0) {
  1922.                     Util.Log("URTMethod.PrintCSC Invoke _params[0] 1 PrintCSC");
  1923.                     ((URTParam)_params[0]).PrintCSC(sb, curNS);
  1924.                     for (int i = 1; i < _params.Count; i++) {
  1925.                         sb.Append(", ");
  1926.                         Util.Log("URTMethod.PrintCSC Invoke _params 2 PrintCSC");
  1927.                         ((URTParam)_params[i]).PrintCSC(sb, curNS);
  1928.                     }
  1929.                 }
  1930.                 sb.Append(')');
  1931.                 if (!bPrintBody)
  1932.                     sb.Append(';');
  1933.                 textWriter.WriteLine(sb);
  1934.                
  1935.                 if (bPrintBody) {
  1936.                     sb.Length = 0;
  1937.                     sb.Append(indentation);
  1938.                     sb.Append('{');
  1939.                     textWriter.WriteLine(sb);
  1940.                    
  1941.                     string newIndentation = indentation + " ";
  1942.                     if (bodyPrefix == null) {
  1943.                         for (int i = 0; i < _params.Count; i++) {
  1944.                             URTParam param = (URTParam)_params[i];
  1945.                             if (param.ParamType == URTParamType.OUT) {
  1946.                                 sb.Length = 0;
  1947.                                 sb.Append(newIndentation);
  1948.                                 sb.Append(param.Name);
  1949.                                 sb.Append(" = ");
  1950.                                 sb.Append(ValueString(param.GetTypeString(curNS)));
  1951.                                 sb.Append(';');
  1952.                                 textWriter.WriteLine(sb);
  1953.                             }
  1954.                         }
  1955.                         Util.Log("URTMethod.PrintCSC return print");
  1956.                         sb.Length = 0;
  1957.                         sb.Append(newIndentation);
  1958.                         sb.Append("return");
  1959.                         string returnString = ValueString(GetTypeString(curNS));
  1960.                         if (returnString != null) {
  1961.                             sb.Append('(');
  1962.                             sb.Append(returnString);
  1963.                             sb.Append(')');
  1964.                         }
  1965.                         sb.Append(';');
  1966.                     }
  1967.                     else {
  1968.                         sb.Length = 0;
  1969.                         sb.Append(newIndentation);
  1970.                         if (ValueString(GetTypeString(curNS)) != null)
  1971.                             sb.Append("return ");
  1972.                         sb.Append(bodyPrefix);
  1973.                         sb.Append(_methodName);
  1974.                         sb.Append('(');
  1975.                         if (_params.Count > 0) {
  1976.                             Util.Log("URTMethod.PrintCSC Invoke _params[0] 3 PrintCSC");
  1977.                             ((URTParam)_params[0]).PrintCSC(sb);
  1978.                             for (int i = 1; i < _params.Count; i++) {
  1979.                                 sb.Append(", ");
  1980.                                 Util.Log("URTMethod.PrintCSC Invoke _params 4 PrintCSC");
  1981.                                 ((URTParam)_params[i]).PrintCSC(sb);
  1982.                             }
  1983.                         }
  1984.                         sb.Append(");");
  1985.                     }
  1986.                     textWriter.WriteLine(sb);
  1987.                    
  1988.                     textWriter.Write(indentation);
  1989.                     textWriter.WriteLine('}');
  1990.                 }
  1991.             }
  1992.            
  1993.             // Returns string that is appropriate for the return type
  1994.             static internal string ValueString(string paramType)
  1995.             {
  1996.                 string valueString;
  1997.                 if (paramType == "void")
  1998.                     valueString = null;
  1999.                 else if (paramType == "bool")
  2000.                     valueString = "false";
  2001.                 else if (paramType == "string")
  2002.                     valueString = "null";
  2003.                 else if (paramType == "sbyte" || paramType == "byte" || paramType == "short" || paramType == "ushort" || paramType == "int" || paramType == "uint" || paramType == "long" || paramType == "ulong")
  2004.                     valueString = "1";
  2005.                 else if (paramType == "float" || paramType == "exfloat")
  2006.                     valueString = "(float)1.0";
  2007.                 else if (paramType == "double" || paramType == "exdouble")
  2008.                     valueString = "1.0";
  2009.                 else {
  2010.                     StringBuilder sb = new StringBuilder(50);
  2011.                     sb.Append('(');
  2012.                     sb.Append(paramType);
  2013.                     sb.Append(") (Object) null");
  2014.                     valueString = sb.ToString();
  2015.                 }
  2016.                 Util.Log("URTMethod.ValueString paramType " + paramType + " valueString " + valueString);
  2017.                 return (valueString);
  2018.             }
  2019.            
  2020.             // This method is called when the parsing is complete
  2021.             // and is useful for derived types
  2022.             internal abstract void ResolveTypes(SdlParser parser);
  2023.            
  2024.             // Helper method used by Resolve
  2025.             protected void ResolveParams(SdlParser parser, string targetNS, string targetName, bool bRequest)
  2026.             {
  2027.                 Util.Log("URTMethod.ResolveParams targetName " + targetName + "targetNS " + targetNS + " bRequest " + bRequest);
  2028.                 // Lookup the element declaration using target namespace and type name
  2029.                 URTNamespace elmNS = parser.LookupNamespace(targetNS);
  2030.                 if (elmNS == null) {
  2031.                     throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), targetNS));
  2032.                 }
  2033.                 ElementDecl elm = elmNS.LookupElementDecl(targetName);
  2034.                 if (elm == null) {
  2035.                     throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveElementInNS"), targetName, targetNS));
  2036.                 }
  2037.                
  2038.                 // Lookup the type from the element declaration
  2039.                 URTNamespace typeNS = parser.LookupNamespace(elm.TypeNS);
  2040.                 if (typeNS == null) {
  2041.                     throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), elm.TypeNS));
  2042.                 }
  2043.                 URTComplexType type = typeNS.LookupComplexType(elm.TypeName);
  2044.                 if (type == null) {
  2045.                     throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), elm.TypeName, elm.TypeNS));
  2046.                 }
  2047.                 Util.Log("URTMethod.ResolveParams Before RemoveComplexType ");
  2048.                 typeNS.RemoveComplexType(type);
  2049.                
  2050.                 // The fields of the type are the params of the method
  2051.                 ArrayList fields = type.Fields;
  2052.                 for (int i = 0; i < fields.Count; i++) {
  2053.                     URTField field = (URTField)fields[i];
  2054.                     URTParamType pType = bRequest ? URTParamType.IN : URTParamType.OUT;
  2055.                     AddParam(new URTParam(field.Name, field.TypeName, field.TypeNS, field.EncodedNS, pType, field.IsEmbedded));
  2056.                 }
  2057.                
  2058.                 return;
  2059.             }
  2060.            
  2061.             // Fields
  2062.             private string _methodName;
  2063.             private string _soapAction;
  2064.             private URTParam _methodType;
  2065.             private int _methodFlags;
  2066.             private ArrayList _params;
  2067.         }
  2068.        
  2069.         // Repesents a request response method
  2070.         internal class RRMethod : URTMethod
  2071.         {
  2072.             // Constructor
  2073.             internal RRMethod(string name, string soapAction) : base(name, soapAction)
  2074.             {
  2075.                 Util.Log("RRMethod.RRMethod name " + name + " soapAction " + soapAction);
  2076.                 _requestElementName = null;
  2077.                 _requestElementNS = null;
  2078.                 //_requestTypeName = null;
  2079.                 //_requestTypeNS = null;
  2080.                 _responseElementName = null;
  2081.                 _responseElementNS = null;
  2082.                 //_responseTypeName = null;
  2083.                 //_responseTypeNS = null;
  2084.             }
  2085.            
  2086.             // Adds the request element
  2087.             internal void AddRequest(string name, string ns)
  2088.             {
  2089.                 Util.Log("RRMethod.AddRequest name " + name + " ns " + ns);
  2090.                 _requestElementName = name;
  2091.                 _requestElementNS = ns;
  2092.             }
  2093.            
  2094.             // Adds the response element
  2095.             internal void AddResponse(string name, string ns)
  2096.             {
  2097.                 Util.Log("RRMethod.AddResponse name " + name + " ns " + ns);
  2098.                 _responseElementName = name;
  2099.                 _responseElementNS = ns;
  2100.             }
  2101.            
  2102.             // Resolves the method
  2103.             internal override void ResolveTypes(SdlParser parser)
  2104.             {
  2105.                 Util.Log("RRMethod.ResolveTypes " + _requestElementName + " " + _responseElementName);
  2106.                 ResolveParams(parser, _requestElementNS, _requestElementName, true);
  2107.                 ResolveParams(parser, _responseElementNS, _responseElementName, false);
  2108.                 return;
  2109.             }
  2110.            
  2111.             internal override void PrintCSC(TextWriter textWriter, string indentation, string namePrefix, string curNS, bool bPrintBody, bool bURTType, string bodyPrefix, StringBuilder sb)
  2112.             {
  2113.                 Util.Log("RRMethod.PrintCSC name " + _requestElementName + " namePrefix " + namePrefix + " curNS " + curNS + " bPrintBody " + bPrintBody + " bURTType " + bURTType + " bodyPrefix " + bodyPrefix);
  2114.                 //if(bURTType == false)
  2115.                
  2116.                 bool bSoapAction = false;
  2117.                 if (SoapAction != null)
  2118.                     bSoapAction = true;
  2119.                
  2120.                 if (bSoapAction || !bURTType) {
  2121.                     sb.Length = 0;
  2122.                     sb.Append(indentation);
  2123.                     sb.Append("[SoapMethod(");
  2124.                    
  2125.                     if (bSoapAction) {
  2126.                         sb.Append("SoapAction=\"");
  2127.                         sb.Append(SoapAction);
  2128.                         sb.Append("\"");
  2129.                     }
  2130.                     if (!bURTType) {
  2131.                         if (bSoapAction)
  2132.                             sb.Append(",");
  2133.                        
  2134.                         sb.Append("ResponseXmlElementName=\"");
  2135.                         sb.Append(_responseElementName);
  2136.                         if (MethodType != null) {
  2137.                             sb.Append("\", ReturnXmlElementName=\"");
  2138.                             sb.Append(MethodType.Name);
  2139.                         }
  2140.                         sb.Append("\", XmlNamespace=\"");
  2141.                         sb.Append(_requestElementNS);
  2142.                         sb.Append("\", ResponseXmlNamespace=\"");
  2143.                         sb.Append(_responseElementNS);
  2144.                         sb.Append("\"");
  2145.                     }
  2146.                     sb.Append(")]");
  2147.                     textWriter.WriteLine(sb);
  2148.                 }
  2149.                
  2150.                 Util.Log("RRMethod.PrintCSC Invoke base PrintCSC");
  2151.                 base.PrintCSC(textWriter, indentation, namePrefix, curNS, bPrintBody, bodyPrefix, sb);
  2152.                 return;
  2153.             }
  2154.            
  2155.             // Fields
  2156.             private string _requestElementName;
  2157.             private string _requestElementNS;
  2158.             //private String _requestTypeName;
  2159.             //private String _requestTypeNS;
  2160.             private string _responseElementName;
  2161.             private string _responseElementNS;
  2162.             //private String _responseTypeName;
  2163.             //private String _responseTypeNS;
  2164.         }
  2165.        
  2166.         // Reperents a oneway method
  2167.         internal class OnewayMethod : URTMethod
  2168.         {
  2169.             // Constructor
  2170.             internal OnewayMethod(string name, string soapAction) : base(name, soapAction)
  2171.             {
  2172.                 Util.Log("OnewayMethod.OnewayMethod name " + name + " soapAction " + soapAction);
  2173.                 _messageElementName = null;
  2174.                 _messageElementNS = null;
  2175.                 //_messageTypeName = null;
  2176.                 //_messageTypeNS = null;
  2177.             }
  2178.            
  2179.             // Adds the request element
  2180.             internal void AddMessage(string name, string ns)
  2181.             {
  2182.                 Util.Log("OnewayMethod.AddMessage name " + name + " ns " + ns);
  2183.                 _messageElementName = name;
  2184.                 _messageElementNS = ns;
  2185.             }
  2186.            
  2187.             // Resolves the method
  2188.             internal override void ResolveTypes(SdlParser parser)
  2189.             {
  2190.                 Util.Log("OnewayMethod.ResolveTypes name " + _messageElementName);
  2191.                 ResolveParams(parser, _messageElementNS, _messageElementName, true);
  2192.                 return;
  2193.             }
  2194.            
  2195.             // Writes the oneway attribute and delegates to the base implementation
  2196.             internal override void PrintCSC(TextWriter textWriter, string indentation, string namePrefix, string curNS, bool bPrintBody, bool bURTType, string bodyPrefix, StringBuilder sb)
  2197.             {
  2198.                 Util.Log("OnewayMethod.PrintCSC name " + _messageElementName + " namePrefix " + namePrefix + " curNS " + curNS + " bPrintBody " + bPrintBody + " bURTType " + bURTType + " bodyPrefix " + bodyPrefix);
  2199.                 textWriter.Write(indentation);
  2200.                 textWriter.WriteLine("[OneWay]");
  2201.                
  2202.                 //bURTType == false)
  2203.                 if (SoapAction != null) {
  2204.                     sb.Length = 0;
  2205.                     sb.Append(indentation);
  2206.                     sb.Append("[SoapMethod(SoapAction=\"");
  2207.                     sb.Append(SoapAction);
  2208.                     sb.Append("\", XmlNamespace=\"");
  2209.                     sb.Append(_messageElementNS);
  2210.                     sb.Append("\")]");
  2211.                     textWriter.WriteLine(sb);
  2212.                 }
  2213.                
  2214.                 Util.Log("OnewayMethod.PrintCSC Invoke base PrintCSC");
  2215.                 base.PrintCSC(textWriter, indentation, namePrefix, curNS, bPrintBody, bodyPrefix, sb);
  2216.                
  2217.                 return;
  2218.             }
  2219.            
  2220.             // Fields
  2221.             private string _messageElementName;
  2222.             private string _messageElementNS;
  2223.             //private String _messageTypeName;
  2224.             //private String _messageTypeNS;
  2225.         }
  2226.        
  2227.         // Base class for interfaces
  2228.         internal abstract class BaseInterface
  2229.         {
  2230.             internal BaseInterface(string name, string ns, string encodedNS)
  2231.             {
  2232.                 Util.Log("BaseInterface.BaseInterface");
  2233.                 _name = name;
  2234.                 _namespace = ns;
  2235.                 _encodedNS = encodedNS;
  2236.             }
  2237.             internal string Name {
  2238.                 get { return (_name); }
  2239.             }
  2240.             internal string Namespace {
  2241.                 get { return (_namespace); }
  2242.             }
  2243.             internal bool IsURTInterface {
  2244.                 get { return ((object)_namespace == (object)_encodedNS); }
  2245.             }
  2246.             internal string GetName(string curNS)
  2247.             {
  2248.                 string name;
  2249.                 if (SdlParser.Qualify(_namespace, curNS)) {
  2250.                     StringBuilder sb = new StringBuilder(_encodedNS, 50);
  2251.                     sb.Append('.');
  2252.                     sb.Append(_name);
  2253.                     name = sb.ToString();
  2254.                 }
  2255.                 else
  2256.                     name = _name;
  2257.                
  2258.                 Util.Log("BaseInterface.GetName curNS " + curNS);
  2259.                 return (name);
  2260.             }
  2261.             internal abstract void PrintClassMethods(TextWriter textWriter, string indentation, string curNS, ArrayList printedIFaces, bool bProxy, StringBuilder sb);
  2262.             private string _name;
  2263.             private string _namespace;
  2264.             private string _encodedNS;
  2265.         }
  2266.        
  2267.         // Represents a system interface
  2268.         internal class SystemInterface : BaseInterface
  2269.         {
  2270.             internal SystemInterface(string name, string ns) : base(name, ns, ns)
  2271.             {
  2272.                 Util.Log("SystemInterface.SystemInterface");
  2273.                 Debug.Assert(ns.StartsWith("System"), "Invalid System type");
  2274.                 string fullName = ns + '.' + name;
  2275.                 _type = Type.GetType(fullName, true);
  2276.             }
  2277.             internal override void PrintClassMethods(TextWriter textWriter, string indentation, string curNS, ArrayList printedIFaces, bool bProxy, StringBuilder sb)
  2278.             {
  2279.                 Util.Log("SystemInterface.PrintClassMethods " + curNS + " bProxy " + bProxy);
  2280.                 // Return if the interfaces has already been printed
  2281.                 int i;
  2282.                 for (i = 0; i < printedIFaces.Count; i++) {
  2283.                     if (printedIFaces[i] is SystemInterface) {
  2284.                         SystemInterface iface = (SystemInterface)printedIFaces[i];
  2285.                         if (iface._type == _type)
  2286.                             return;
  2287.                     }
  2288.                 }
  2289.                 printedIFaces.Add(this);
  2290.                
  2291.                 // Count of implemented methods
  2292.                 BindingFlags bFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public;
  2293.                 // | BindingFlags.NonPublic;
  2294.                 ArrayList types = new ArrayList();
  2295.                 sb.Length = 0;
  2296.                 types.Add(_type);
  2297.                 i = 0;
  2298.                 int j = 1;
  2299.                 while (i < j) {
  2300.                     Type type = (Type)types[i];
  2301.                     MethodInfo[] methods = type.GetMethods(bFlags);
  2302.                     Type[] iFaces = type.GetInterfaces();
  2303.                     for (int k = 0; k < iFaces.Length; k++) {
  2304.                         for (int l = 0; l < j; l++) {
  2305.                             if (types[i] == iFaces[k])
  2306.                                 goto Loopback;
  2307.                         }
  2308.                         types.Add(iFaces[k]);
  2309.                         j++;
  2310.                         Loopback:
  2311.                         continue;
  2312.                     }
  2313.                    
  2314.                     for (int k = 0; k < methods.Length; k++) {
  2315.                         MethodInfo method = methods[k];
  2316.                         sb.Length = 0;
  2317.                         sb.Append(indentation);
  2318.                         sb.Append(CSharpTypeString(method.ReturnType.FullName));
  2319.                         sb.Append(' ');
  2320.                         sb.Append(type.FullName);
  2321.                         sb.Append('.');
  2322.                         sb.Append(method.Name);
  2323.                         sb.Append('(');
  2324.                         ParameterInfo[] parameters = method.GetParameters();
  2325.                         for (int l = 0; l < parameters.Length; l++) {
  2326.                             if (l != 0)
  2327.                                 sb.Append(", ");
  2328.                             ParameterInfo param = parameters[l];
  2329.                             Type parameterType = param.ParameterType;
  2330.                             if (param.IsIn)
  2331.                                 sb.Append("in ");
  2332.                             else if (param.IsOut)
  2333.                                 sb.Append("out ");
  2334.                             else if (parameterType.IsByRef) {
  2335.                                 sb.Append("ref ");
  2336.                                 parameterType = parameterType.GetElementType();
  2337.                             }
  2338.                             sb.Append(CSharpTypeString(parameterType.FullName));
  2339.                             sb.Append(' ');
  2340.                             sb.Append(param.Name);
  2341.                         }
  2342.                         sb.Append(')');
  2343.                         textWriter.WriteLine(sb);
  2344.                        
  2345.                         textWriter.Write(indentation);
  2346.                         textWriter.WriteLine('{');
  2347.                        
  2348.                         string newIndentation = indentation + " ";
  2349.                         if (bProxy == false) {
  2350.                             for (int l = 0; l < parameters.Length; l++) {
  2351.                                 ParameterInfo param = parameters[l];
  2352.                                 Type parameterType = param.ParameterType;
  2353.                                 if (param.IsOut) {
  2354.                                     sb.Length = 0;
  2355.                                     sb.Append(newIndentation);
  2356.                                     sb.Append(param.Name);
  2357.                                     sb.Append(URTMethod.ValueString(CSharpTypeString(param.ParameterType.FullName)));
  2358.                                     sb.Append(';');
  2359.                                     textWriter.WriteLine(sb);
  2360.                                 }
  2361.                             }
  2362.                            
  2363.                             Util.Log("SystemInterface.PrintClassMethods return 1 print");
  2364.                             sb.Length = 0;
  2365.                             sb.Append(newIndentation);
  2366.                             sb.Append("return");
  2367.                             string valueString = URTMethod.ValueString(CSharpTypeString(method.ReturnType.FullName));
  2368.                             if (valueString != null) {
  2369.                                 sb.Append('(');
  2370.                                 sb.Append(valueString);
  2371.                                 sb.Append(')');
  2372.                             }
  2373.                             sb.Append(';');
  2374.                         }
  2375.                         else {
  2376.                             Util.Log("SystemInterface.PrintClassMethods return 2 print");
  2377.                             sb.Length = 0;
  2378.                             sb.Append(newIndentation);
  2379.                             sb.Append("return((");
  2380.                             sb.Append(type.FullName);
  2381.                             sb.Append(") _tp).");
  2382.                             sb.Append(method.Name);
  2383.                             sb.Append('(');
  2384.                             if (parameters.Length > 0) {
  2385.                                 int lastParameter = parameters.Length - 1;
  2386.                                 for (int l = 0; l < parameters.Length; l++) {
  2387.                                     ParameterInfo param = parameters[0];
  2388.                                     Type parameterType = param.ParameterType;
  2389.                                     if (param.IsIn)
  2390.                                         sb.Append("in ");
  2391.                                     else if (param.IsOut)
  2392.                                         sb.Append("out ");
  2393.                                     else if (parameterType.IsByRef)
  2394.                                         sb.Append("ref ");
  2395.                                     sb.Append(param.Name);
  2396.                                     if (l < lastParameter)
  2397.                                         sb.Append(", ");
  2398.                                 }
  2399.                             }
  2400.                             sb.Append(");");
  2401.                         }
  2402.                         textWriter.WriteLine(sb);
  2403.                        
  2404.                         textWriter.Write(indentation);
  2405.                         textWriter.WriteLine('}');
  2406.                     }
  2407.                    
  2408.                     ++i;
  2409.                 }
  2410.                
  2411.                 return;
  2412.             }
  2413.             private static string CSharpTypeString(string typeName)
  2414.             {
  2415.                 Util.Log("SystemInterface.CSharpTypeString typeName " + typeName);
  2416.                 string CSCTypeName = typeName;
  2417.                 if (typeName == "System.SByte")
  2418.                     CSCTypeName = "sbyte";
  2419.                 else if (typeName == "System.byte")
  2420.                     CSCTypeName = "byte";
  2421.                 else if (typeName == "System.Int16")
  2422.                     CSCTypeName = "short";
  2423.                 else if (typeName == "System.UInt16")
  2424.                     CSCTypeName = "ushort";
  2425.                 else if (typeName == "System.Int32")
  2426.                     CSCTypeName = "int";
  2427.                 else if (typeName == "System.UInt32")
  2428.                     CSCTypeName = "uint";
  2429.                 else if (typeName == "System.Int64")
  2430.                     CSCTypeName = "long";
  2431.                 else if (typeName == "System.UInt64")
  2432.                     CSCTypeName = "ulong";
  2433.                 else if (typeName == "System.Char")
  2434.                     CSCTypeName = "char";
  2435.                 else if (typeName == "System.Single")
  2436.                     CSCTypeName = "float";
  2437.                 else if (typeName == "System.Double")
  2438.                     CSCTypeName = "double";
  2439.                 else if (typeName == "System.Boolean")
  2440.                     CSCTypeName = "boolean";
  2441.                 else if (typeName == "System.Void")
  2442.                     CSCTypeName = "void";
  2443.                 else if (typeName == "System.String")
  2444.                     CSCTypeName = "String";
  2445.                
  2446.                 return (CSCTypeName);
  2447.             }
  2448.            
  2449.             Type _type;
  2450.         }
  2451.        
  2452.         // Represents an interface
  2453.        
  2454.         internal class URTInterface : BaseInterface
  2455.         {
  2456.             internal URTInterface(string name, string ns, string encodedNS) : base(name, ns, encodedNS)
  2457.             {
  2458.                 Util.Log("URTInterface.URTInterface name " + name + " ns " + ns + " encodedNS " + encodedNS);
  2459.                 _baseIFaces = new ArrayList();
  2460.                 _baseIFaceNames = new ArrayList();
  2461.                 _methods = new ArrayList();
  2462.             }
  2463.             internal void Extends(string baseName, string baseNS, SdlParser parser)
  2464.             {
  2465.                 Util.Log("URTInterface.Extends baseName " + baseName + " baseNSf " + baseNS);
  2466.                 _baseIFaceNames.Add(baseName);
  2467.                 _baseIFaceNames.Add(baseNS);
  2468.                 // Urt namespace will not have schema, they need to be recorded.
  2469.                 URTNamespace parsingNamespace = parser.LookupNamespace(baseNS);
  2470.                 if (parsingNamespace == null) {
  2471.                     parsingNamespace = new URTNamespace(baseNS, parser);
  2472.                     parser._URTNamespaces.Add(parsingNamespace);
  2473.                 }
  2474.                
  2475.                 URTInterface parsingInterface = parsingNamespace.LookupInterface(baseName);
  2476.                 if (parsingInterface == null) {
  2477.                     parsingInterface = new URTInterface(baseName, parsingNamespace.Namespace, parsingNamespace.EncodedNS);
  2478.                     parsingNamespace.AddInterface(parsingInterface);
  2479.                 }
  2480.                
  2481.             }
  2482.             internal void AddMethod(URTMethod method)
  2483.             {
  2484.                 Util.Log("URTInterface.AddMethod method " + method.Name);
  2485.                 _methods.Add(method);
  2486.             }
  2487.             internal void ResolveTypes(SdlParser parser)
  2488.             {
  2489.                 Util.Log("URTInterface.ResolveTypes " + Name);
  2490.                 for (int i = 0; i < _baseIFaceNames.Count; i = i + 2) {
  2491.                     string baseIFaceName = (string)_baseIFaceNames[i];
  2492.                     string baseIFaceXmlNS = (string)_baseIFaceNames[i + 1];
  2493.                     string baseIFaceNS;
  2494.                     string baseIFaceAssemName;
  2495.                     BaseInterface iFace;
  2496.                     UrtType iType = parser.IsURTExportedType(baseIFaceXmlNS, out baseIFaceNS, out baseIFaceAssemName);
  2497.                    
  2498.                     Util.Log("URTInterface.ResolveTypes Is System " + Name + " iType " + ((Enum)iType).ToString() + " baseIFaceNS " + baseIFaceNS);
  2499.                     if ((iType != UrtType.Interop) && baseIFaceNS.StartsWith("System")) {
  2500.                         iFace = new SystemInterface(baseIFaceName, baseIFaceNS);
  2501.                     }
  2502.                     else {
  2503.                         URTNamespace ns = parser.LookupNamespace(baseIFaceXmlNS);
  2504.                         if (ns == null) {
  2505.                             throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), baseIFaceXmlNS));
  2506.                         }
  2507.                         iFace = ns.LookupInterface(baseIFaceName);
  2508.                         if (iFace == null) {
  2509.                             throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), baseIFaceName, baseIFaceXmlNS));
  2510.                         }
  2511.                     }
  2512.                     _baseIFaces.Add(iFace);
  2513.                 }
  2514.                 for (int i = 0; i < _methods.Count; i++)
  2515.                     ((URTMethod)_methods[i]).ResolveTypes(parser);
  2516.             }
  2517.             internal void PrintCSC(TextWriter textWriter, string indentation, string curNS, StringBuilder sb)
  2518.             {
  2519.                 Util.Log("URTInterface.PrintCSC name " + Name + " curNS " + curNS);
  2520.                 bool bURTType = IsURTInterface;
  2521.                 if (bURTType == false) {
  2522.                     sb.Length = 0;
  2523.                     sb.Append(indentation);
  2524.                     sb.Append("[SoapType(XmlElementName=\"");
  2525.                     sb.Append(Name);
  2526.                     sb.Append("\", XmlNamespace=\"");
  2527.                     sb.Append(Namespace);
  2528.                     sb.Append("\", XmlTypeName=\"");
  2529.                     sb.Append(Name);
  2530.                     sb.Append("\", XmlTypeNamespace=\"");
  2531.                     sb.Append(Namespace);
  2532.                     sb.Append("\")]");
  2533.                     textWriter.WriteLine(sb);
  2534.                 }
  2535.                
  2536.                 sb.Length = 0;
  2537.                 sb.Append(indentation);
  2538.                 sb.Append("public interface ");
  2539.                 sb.Append(Name);
  2540.                
  2541.                 if (_baseIFaces.Count > 0)
  2542.                     sb.Append(" : ");
  2543.                
  2544.                 if (_baseIFaces.Count > 0) {
  2545.                     sb.Append(((BaseInterface)_baseIFaces[0]).GetName(curNS));
  2546.                     for (int i = 1; i < _baseIFaces.Count; i++) {
  2547.                         sb.Append(((BaseInterface)_baseIFaces[i]).GetName(curNS));
  2548.                     }
  2549.                 }
  2550.                
  2551.                 textWriter.WriteLine(sb);
  2552.                
  2553.                 textWriter.Write(indentation);
  2554.                 textWriter.WriteLine('{');
  2555.                
  2556.                 string newIndentation = indentation + " ";
  2557.                 string namePrefix = " ";
  2558.                 Util.Log("URTInterface.PrintCSC method count " + _methods.Count);
  2559.                 for (int i = 0; i < _methods.Count; i++) {
  2560.                     Util.Log("URTInterface.PrintCSC Invoke methods PrintCSC");
  2561.                     ((URTMethod)_methods[i]).PrintCSC(textWriter, newIndentation, namePrefix, curNS, false, bURTType, null, sb);
  2562.                 }
  2563.                 textWriter.Write(indentation);
  2564.                 textWriter.WriteLine('}');
  2565.             }
  2566.             internal override void PrintClassMethods(TextWriter textWriter, string indentation, string curNS, ArrayList printedIFaces, bool bProxy, StringBuilder sb)
  2567.             {
  2568.                 Util.Log("URTInterface.PrintClassMethods method " + Name + " curNS " + curNS + " bProxy " + bProxy);
  2569.                 // Return if the interface has already been printed
  2570.                 for (int i = 0; i < printedIFaces.Count; i++) {
  2571.                     if (printedIFaces[i] == this) {
  2572.                         Util.Log("URTInterface.PrintClassMethods printedIFaces return " + Name);
  2573.                         return;
  2574.                     }
  2575.                 }
  2576.                 Util.Log("URTInterface.PrintClassMethods method 2 " + Name + " _methods.Count " + _methods.Count);
  2577.                 printedIFaces.Add(this);
  2578.                 sb.Length = 0;
  2579.                 sb.Append(indentation);
  2580.                 if (_methods.Count > 0) {
  2581.                     sb.Append("// ");
  2582.                     sb.Append(Name);
  2583.                     sb.Append(" interface Methods");
  2584.                     textWriter.WriteLine(sb);
  2585.                    
  2586.                     sb.Length = 0;
  2587.                     sb.Append(' ');
  2588.                     string ifaceName = GetName(curNS);
  2589.                     sb.Append(ifaceName);
  2590.                     sb.Append('.');
  2591.                     string namePrefix = sb.ToString();
  2592.                    
  2593.                     string bodyPrefix = null;
  2594.                     if (bProxy) {
  2595.                         sb.Length = 0;
  2596.                         sb.Append("((");
  2597.                         sb.Append(ifaceName);
  2598.                         sb.Append(") _tp).");
  2599.                         bodyPrefix = sb.ToString();
  2600.                     }
  2601.                     for (int i = 0; i < _methods.Count; i++) {
  2602.                         Util.Log("URTInterface.PrintClassMethods Invoke methods PrintCSC " + Name);
  2603.                         ((URTMethod)_methods[i]).PrintCSC(textWriter, indentation, namePrefix, curNS, true, true, bodyPrefix, sb);
  2604.                     }
  2605.                 }
  2606.                
  2607.                 for (int i = 0; i < _baseIFaces.Count; i++) {
  2608.                     ((BaseInterface)_baseIFaces[i]).PrintClassMethods(textWriter, indentation, curNS, printedIFaces, bProxy, sb);
  2609.                 }
  2610.             }
  2611.            
  2612.             private ArrayList _baseIFaces;
  2613.             private ArrayList _baseIFaceNames;
  2614.             private ArrayList _methods;
  2615.         }
  2616.        
  2617.         // Represents a field of a type
  2618.         internal class URTField
  2619.         {
  2620.             internal URTField(string name, string typeName, string xmlNS, SdlParser parser, bool bPrimitive, bool bEmbedded, bool bAttribute, bool bOptional, bool bArray, string arraySize
  2621.             )
  2622.             {
  2623.                 Util.Log("URTField.URTField " + name + " typeName " + typeName + " xmlNS " + xmlNS + " bPrimitive " + bPrimitive + " bEmbedded " + bEmbedded + " bAttribute " + bAttribute);
  2624.                 _name = name;
  2625.                 _typeName = typeName;
  2626.                 string typeAssemName;
  2627.                 UrtType urtType = parser.IsURTExportedType(xmlNS, out _typeNS, out typeAssemName);
  2628.                 if (urtType == UrtType.Interop)
  2629.                     _encodedNS = "InteropProxy";
  2630.                 else
  2631.                     _encodedNS = _typeNS;
  2632.                 _primitiveField = bPrimitive;
  2633.                 _embeddedField = bEmbedded;
  2634.                 _attributeField = bAttribute;
  2635.                 _optionalField = bOptional;
  2636.                 _arrayField = bArray;
  2637.                 _arraySize = arraySize;
  2638.             }
  2639.             internal string Name {
  2640.                 get { return (_name); }
  2641.             }
  2642.             internal string TypeName {
  2643.                 get {
  2644.                     if (_arrayField)
  2645.                         return (_typeName + "[]");
  2646.                     return (_typeName);
  2647.                 }
  2648.             }
  2649.             internal string TypeNS {
  2650.                 get { return (_typeNS); }
  2651.             }
  2652.             internal string EncodedNS {
  2653.                 get { return (_encodedNS); }
  2654.             }
  2655.             internal bool IsPrimitive {
  2656.                 get { return (_primitiveField); }
  2657.             }
  2658.             internal bool IsEmbedded {
  2659.                 get { return (_embeddedField); }
  2660.             }
  2661.             internal bool IsAttribute {
  2662.                 get { return (_attributeField); }
  2663.             }
  2664.             internal bool IsArray {
  2665.                 get { return (_arrayField); }
  2666.             }
  2667.             internal bool IsOptional {
  2668.                 get { return (_optionalField); }
  2669.             }
  2670.             internal string GetTypeString(string curNS)
  2671.             {
  2672.                 string type;
  2673.                 if (SdlParser.Qualify(_typeNS, curNS)) {
  2674.                     StringBuilder sb = new StringBuilder(_encodedNS, 50);
  2675.                     sb.Append('.');
  2676.                     sb.Append(TypeName);
  2677.                     type = sb.ToString();
  2678.                 }
  2679.                 else
  2680.                     type = TypeName;
  2681.                
  2682.                 Util.Log("URTField.GetTypeString curNS " + curNS + " type " + type);
  2683.                 return (type);
  2684.             }
  2685.             internal void PrintCSC(TextWriter textWriter, string indentation, string curNS, StringBuilder sb)
  2686.             {
  2687.                 Util.Log("URTField.PrintCSC name " + _name + " curNS" + curNS);
  2688.                 if (_embeddedField) {
  2689.                     textWriter.Write(indentation);
  2690.                     textWriter.WriteLine("[SoapField(Embedded=true)]");
  2691.                 }
  2692.                
  2693.                 sb.Length = 0;
  2694.                 sb.Append(indentation);
  2695.                 sb.Append("public ");
  2696.                 sb.Append(GetTypeString(curNS));
  2697.                 sb.Append(' ');
  2698.                 sb.Append(_name);
  2699.                 sb.Append(';');
  2700.                 textWriter.WriteLine(sb);
  2701.             }
  2702.            
  2703.             private string _name;
  2704.             private string _typeName;
  2705.             private string _typeNS;
  2706.             private string _encodedNS;
  2707.             private bool _primitiveField;
  2708.             private bool _embeddedField;
  2709.             private bool _attributeField;
  2710.             private bool _optionalField;
  2711.             private bool _arrayField;
  2712.             private string _arraySize;
  2713.         }
  2714.        
  2715.         internal abstract class SchemaFacet
  2716.         {
  2717.             protected SchemaFacet()
  2718.             {
  2719.             }
  2720.             internal virtual void ResolveTypes(SdlParser parser)
  2721.             {
  2722.             }
  2723.             internal abstract void PrintCSC(TextWriter textWriter, string newIndentation, string curNS, StringBuilder sb);
  2724.         }
  2725.        
  2726.         internal class EnumFacet : SchemaFacet
  2727.         {
  2728.             internal EnumFacet(string valueString, int value) : base()
  2729.             {
  2730.                 Util.Log("EnumFacet.EnumFacet valueString " + valueString + " value " + value);
  2731.                 _valueString = valueString;
  2732.                 _value = value;
  2733.             }
  2734.             internal override void PrintCSC(TextWriter textWriter, string newIndentation, string curNS, StringBuilder sb)
  2735.             {
  2736.                 Util.Log("EnumFacet.PrintCSC _valueString " + _valueString + " value " + _value + " curNS " + curNS);
  2737.                 sb.Length = 0;
  2738.                 sb.Append(newIndentation);
  2739.                 sb.Append(_valueString);
  2740.                 sb.Append(" = ");
  2741.                 sb.Append(_value);
  2742.                 sb.Append(',');
  2743.                 textWriter.WriteLine(sb);
  2744.                 return;
  2745.             }
  2746.            
  2747.             private string _valueString;
  2748.             private int _value;
  2749.         }
  2750.        
  2751.         // Represents a Base type
  2752.         internal abstract class BaseType
  2753.         {
  2754.             internal BaseType(string name, string ns, string encodedNS)
  2755.             {
  2756.                 _name = name;
  2757.                 _namespace = ns;
  2758.                 _elementName = _name;
  2759.                 _elementNS = ns;
  2760.                 _encodedNS = encodedNS;
  2761.             }
  2762.             internal string Name {
  2763.                 get { return (_name); }
  2764.             }
  2765.             internal string Namespace {
  2766.                 get { return (_namespace); }
  2767.             }
  2768.             internal string ElementName {
  2769.                 get { return (_elementName); }
  2770.                 set { _elementName = value; }
  2771.             }
  2772.             internal string ElementNS {
  2773.                 get { return (_elementNS); }
  2774.                 set { _elementNS = value; }
  2775.             }
  2776.             internal bool IsURTType {
  2777.                 get {
  2778.                     Util.Log("BaseType.IsURTType _namespace " + _namespace + " _encodedNS " + _encodedNS + " " + ((object)_namespace == (object)_encodedNS));
  2779.                     return ((object)_namespace == (object)_encodedNS);
  2780.                 }
  2781.             }
  2782.            
  2783.             internal bool IsInteropType {
  2784.                 get { return ((object)_namespace != (object)_encodedNS); }
  2785.             }
  2786.            
  2787.             internal virtual string GetName(string curNS)
  2788.             {
  2789.                 string name;
  2790.                 if (MatchingStrings(_namespace, curNS))
  2791.                     name = _name;
  2792.                 else {
  2793.                     StringBuilder sb = new StringBuilder(_encodedNS, 50);
  2794.                     sb.Append('.');
  2795.                     sb.Append(_name);
  2796.                     name = sb.ToString();
  2797.                 }
  2798.                
  2799.                 return (name);
  2800.             }
  2801.             internal abstract int GetMethodFlags(URTMethod method);
  2802.             internal abstract bool IsEmittableFieldType {
  2803.                 get;
  2804.             }
  2805.             internal abstract string FieldName {
  2806.                 get;
  2807.             }
  2808.            
  2809.             internal abstract string FieldNamespace {
  2810.                 get;
  2811.             }
  2812.            
  2813.             internal abstract bool PrimitiveField {
  2814.                 get;
  2815.             }
  2816.            
  2817.             private string _name;
  2818.             private string _namespace;
  2819.             private string _elementName;
  2820.             private string _elementNS;
  2821.             private string _encodedNS;
  2822.         }
  2823.        
  2824.         // Represents a system type
  2825.         internal class SystemType : BaseType
  2826.         {
  2827.             internal SystemType(string name, string ns, string assemName) : base(name, ns, ns)
  2828.             {
  2829.                 Util.Log("SystemType.SystemType name " + name + " ns " + ns + " assemName " + assemName);
  2830.                 Debug.Assert(ns.StartsWith("System"), "Invalid System type");
  2831.                 string fullName = ns + '.' + name;
  2832.                 if (assemName != null)
  2833.                     fullName = fullName + ',' + assemName;
  2834.                 _type = Type.GetType(fullName, true);
  2835.             }
  2836.             internal override int GetMethodFlags(URTMethod method)
  2837.             {
  2838.                 BindingFlags bFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
  2839.                 Type type = _type;
  2840.                 while (type != null) {
  2841.                     MethodInfo[] methods = type.GetMethods(bFlags);
  2842.                     for (int i = 0; i < methods.Length; i++) {
  2843.                         int methodFlags = method.GetMethodFlags(methods[i]);
  2844.                         if (methodFlags != 0)
  2845.                             return (methodFlags);
  2846.                     }
  2847.                     type = type.BaseType;
  2848.                 }
  2849.                
  2850.                 return (0);
  2851.             }
  2852.             internal override bool IsEmittableFieldType {
  2853.                 get { return (true); }
  2854.             }
  2855.            
  2856.             internal override string FieldName {
  2857.                 get { return (null); }
  2858.             }
  2859.             internal override string FieldNamespace {
  2860.                 get { return (null); }
  2861.             }
  2862.             internal override bool PrimitiveField {
  2863.                 get { return (false); }
  2864.             }
  2865.            
  2866.             private Type _type;
  2867.         }
  2868.        
  2869.         // Represents a simple type
  2870.         internal class URTSimpleType : BaseType
  2871.         {
  2872.             internal URTSimpleType(string name, string ns, string encodedNS, bool bAnonymous) : base(name, ns, encodedNS)
  2873.             {
  2874.                 Util.Log("URTSimpleType.URTSimpleType name " + name + " ns " + ns + " encodedNS " + encodedNS + " bAnonymous " + bAnonymous);
  2875.                 _baseTypeName = null;
  2876.                 _baseTypeXmlNS = null;
  2877.                 _baseType = null;
  2878.                 _fieldString = null;
  2879.                 _facets = new ArrayList();
  2880.                 _bEnum = false;
  2881.                 _bAnonymous = bAnonymous;
  2882.                 _encoding = null;
  2883.             }
  2884.            
  2885.             internal void Extends(string baseTypeName, string baseTypeNS)
  2886.             {
  2887.                 Util.Log("URTSimpleType.Extends baseTypeName " + baseTypeName + " baseTypeNS " + baseTypeNS);
  2888.                 _baseTypeName = baseTypeName;
  2889.                 _baseTypeXmlNS = baseTypeNS;
  2890.                
  2891.             }
  2892.            
  2893.             internal bool IsEnum {
  2894.                 get { return (_bEnum); }
  2895.                 set { _bEnum = value; }
  2896.             }
  2897.            
  2898.             internal string Encoding {
  2899.                 get { return (_encoding); }
  2900.                 set { _encoding = value; }
  2901.             }
  2902.            
  2903.             internal void AddFacet(SchemaFacet facet)
  2904.             {
  2905.                 Util.Log("URTSimpleType.AddFacet");
  2906.                 _facets.Add(facet);
  2907.             }
  2908.            
  2909.             internal bool IsAnonymous {
  2910.                 get { return _bAnonymous; }
  2911.             }
  2912.            
  2913.             internal override bool IsEmittableFieldType {
  2914.                 get {
  2915.                     if (_fieldString == null) {
  2916.                         if ((_bAnonymous == true) && (_facets.Count == 0) && (_encoding != null) && (_baseTypeName == "binary") && (_baseTypeXmlNS == s_schemaNamespaceString))
  2917.                             _fieldString = "byte[]";
  2918.                         else
  2919.                             _fieldString = String.Empty;
  2920.                     }
  2921.                    
  2922.                     return (_fieldString != String.Empty);
  2923.                 }
  2924.             }
  2925.             internal override string FieldName {
  2926.                 get { return (_fieldString); }
  2927.             }
  2928.            
  2929.             internal override string FieldNamespace {
  2930.                 get { return (s_schemaNamespaceString); }
  2931.             }
  2932.            
  2933.             internal override bool PrimitiveField {
  2934.                 get { return (true); }
  2935.             }
  2936.            
  2937.             internal override string GetName(string curNS)
  2938.             {
  2939.                 if ((_fieldString != null) && (_fieldString != String.Empty))
  2940.                     return (_fieldString);
  2941.                
  2942.                 Util.Log("URTSimpleType.GetName curNS " + curNS + " return " + base.GetName(curNS));
  2943.                 return (base.GetName(curNS));
  2944.             }
  2945.            
  2946.             internal void ResolveTypes(SdlParser parser)
  2947.             {
  2948.                 Util.Log("URTSimpleType.ResolveTypes " + Name);
  2949.                 if (_baseTypeName != null) {
  2950.                     if (SdlParser.IsPrimitiveType(_baseTypeXmlNS, _baseTypeName)) {
  2951.                         if (IsEnum == false)
  2952.                             _baseName = SdlParser.MapSchemaTypesToCSharpTypes(_baseTypeName);
  2953.                     }
  2954.                     else {
  2955.                         URTNamespace ns = parser.LookupNamespace(_baseTypeXmlNS);
  2956.                         if (ns == null) {
  2957.                             throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), _baseTypeXmlNS));
  2958.                         }
  2959.                         _baseType = ns.LookupComplexType(_baseTypeName);
  2960.                         if (_baseType == null) {
  2961.                             throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), _baseTypeName, _baseTypeXmlNS));
  2962.                         }
  2963.                     }
  2964.                 }
  2965.                
  2966.                 for (int i = 0; i < _facets.Count; i++)
  2967.                     ((SchemaFacet)_facets[i]).ResolveTypes(parser);
  2968.                
  2969.                 return;
  2970.             }
  2971.             internal void PrintCSC(TextWriter textWriter, string indentation, string curNS, StringBuilder sb)
  2972.             {
  2973.                 Util.Log("URTSimpleType.PrintCSC name " + Name + " curNS " + curNS);
  2974.                 // Print only if the type is not an emittable field type
  2975.                 if (IsEmittableFieldType == true)
  2976.                     return;
  2977.                
  2978.                 // Handle encoding
  2979.                 if (_encoding != null) {
  2980.                     // sb.Length = 0;
  2981.                     // sb.Append(indentation);
  2982.                 }
  2983.                
  2984.                 // Print type
  2985.                 sb.Length = 0;
  2986.                 sb.Append(indentation);
  2987.                
  2988.                 // Handle Enum case
  2989.                 if (IsEnum)
  2990.                     sb.Append("public enum ");
  2991.                 else
  2992.                     sb.Append("public class ");
  2993.                 sb.Append(Name);
  2994.                 if (_baseType != null) {
  2995.                     sb.Append(" : ");
  2996.                     sb.Append(_baseType.GetName(curNS));
  2997.                 }
  2998.                 else if (_baseName != null) {
  2999.                     sb.Append(" : ");
  3000.                     sb.Append(_baseName);
  3001.                 }
  3002.                 textWriter.WriteLine(sb);
  3003.                
  3004.                 textWriter.Write(indentation);
  3005.                 textWriter.WriteLine('{');
  3006.                
  3007.                 string newIndentation = indentation + " ";
  3008.                 for (int i = 0; i < _facets.Count; i++) {
  3009.                     Util.Log("URTSimpleType.PrintCSC Invoke _facets PrintCSC ");
  3010.                     ((SchemaFacet)_facets[i]).PrintCSC(textWriter, newIndentation, curNS, sb);
  3011.                 }
  3012.                
  3013.                 textWriter.Write(indentation);
  3014.                 textWriter.WriteLine('}');
  3015.                
  3016.                 return;
  3017.             }
  3018.             internal override int GetMethodFlags(URTMethod method)
  3019.             {
  3020.                 Debug.Assert(false, "GetMethodFlags called on a SimpleSchemaType");
  3021.                 return (0);
  3022.             }
  3023.            
  3024.             private string _baseTypeName;
  3025.             private string _baseTypeXmlNS;
  3026.             private BaseType _baseType;
  3027.             private string _baseName;
  3028.             private string _fieldString;
  3029.             private bool _bEnum;
  3030.             private bool _bAnonymous;
  3031.             private string _encoding;
  3032.             private ArrayList _facets;
  3033.         }
  3034.        
  3035.         // Represents a complex type
  3036.         internal class URTComplexType : BaseType
  3037.         {
  3038.             internal URTComplexType(string name, string ns, string encodedNS, SchemaBlockType blockDefault, bool bSUDSType, bool bAnonymous) : base(name, ns, encodedNS)
  3039.             {
  3040.                 Util.Log("URTComplexType.URTComplexType name " + name + " ns " + ns + " encodedNS " + encodedNS + " bSUDStype " + bSUDSType + " bAnonymous " + bAnonymous);
  3041.                 _baseTypeName = null;
  3042.                 _baseTypeXmlNS = null;
  3043.                 _baseType = null;
  3044.                 _connectURLs = null;
  3045.                 _bStruct = !bSUDSType;
  3046.                 _blockType = blockDefault;
  3047.                 _bSUDSType = bSUDSType;
  3048.                 _bAnonymous = bAnonymous;
  3049.                 Debug.Assert(bAnonymous == false || _bSUDSType == false);
  3050.                 _fieldString = null;
  3051.                 _fields = new ArrayList();
  3052.                 _methods = new ArrayList();
  3053.                 _implIFaces = new ArrayList();
  3054.                 _implIFaceNames = new ArrayList();
  3055.                 _sudsType = SUDSType.None;
  3056.             }
  3057.             internal void Extends(string baseTypeName, string baseTypeNS)
  3058.             {
  3059.                 Util.Log("URTComplexType.Extends baseTypeName " + baseTypeName + " baseTypeNS " + baseTypeNS);
  3060.                 _baseTypeName = baseTypeName;
  3061.                 _baseTypeXmlNS = baseTypeNS;
  3062.             }
  3063.             internal void Implements(string iFaceName, string iFaceNS, SdlParser parser)
  3064.             {
  3065.                 Util.Log("URTComplexType.Implements IFaceName " + iFaceName + " iFaceNS " + iFaceNS);
  3066.                 _implIFaceNames.Add(iFaceName);
  3067.                 _implIFaceNames.Add(iFaceNS);
  3068.                 // Urt namespace will not have schema, they need to be recorded.
  3069.                 URTNamespace parsingNamespace = parser.LookupNamespace(iFaceNS);
  3070.                 if (parsingNamespace == null) {
  3071.                     parsingNamespace = new URTNamespace(iFaceNS, parser);
  3072.                     parser._URTNamespaces.Add(parsingNamespace);
  3073.                 }
  3074.                
  3075.                 URTInterface parsingInterface = parsingNamespace.LookupInterface(iFaceName);
  3076.                 if (parsingInterface == null) {
  3077.                     parsingInterface = new URTInterface(iFaceName, parsingNamespace.Namespace, parsingNamespace.EncodedNS);
  3078.                     parsingNamespace.AddInterface(parsingInterface);
  3079.                 }
  3080.             }
  3081.             internal ArrayList ConnectURLs {
  3082.                 get { return (_connectURLs); }
  3083.                 set { _connectURLs = value; }
  3084.             }
  3085.             internal bool IsStruct {
  3086.                 get { return (_bStruct); }
  3087.                 set { _bStruct = value; }
  3088.             }
  3089.             internal bool IsSUDSType {
  3090.                 get { return (_bSUDSType); }
  3091.                 set {
  3092.                     _bSUDSType = value;
  3093.                     _bStruct = !value;
  3094.                 }
  3095.             }
  3096.             internal SUDSType SUDSType {
  3097.                 get { return (_sudsType); }
  3098.                 set { _sudsType = value; }
  3099.             }
  3100.             internal SchemaBlockType BlockType {
  3101.                 get { return (_blockType); }
  3102.                 set { _blockType = value; }
  3103.             }
  3104.             internal bool IsAnonymous {
  3105.                 get { return _bAnonymous; }
  3106.             }
  3107.             internal override bool IsEmittableFieldType {
  3108.                 get {
  3109.                     Util.Log("URTComplexType.IsEmittableFieldType _fieldString " + _fieldString + " _bAnonymous " + _bAnonymous + " _fields.Count " + _fields.Count);
  3110.                     if (_fieldString == null) {
  3111.                         if ((_bAnonymous == true) && (_fields.Count == 1)) {
  3112.                             URTField field = (URTField)_fields[0];
  3113.                             if (field.IsArray) {
  3114.                                 _fieldString = field.TypeName;
  3115.                                 return (true);
  3116.                             }
  3117.                         }
  3118.                         _fieldString = String.Empty;
  3119.                     }
  3120.                    
  3121.                     return (_fieldString != String.Empty);
  3122.                 }
  3123.             }
  3124.             internal override string FieldName {
  3125.                 get { return (_fieldString); }
  3126.             }
  3127.             internal override string FieldNamespace {
  3128.                 get { return (((URTField)_fields[0]).TypeNS); }
  3129.             }
  3130.             internal override bool PrimitiveField {
  3131.                 get { return ((((URTField)_fields[0]).IsPrimitive)); }
  3132.             }
  3133.             internal override string GetName(string curNS)
  3134.             {
  3135.                 if ((_fieldString != null) && (_fieldString != String.Empty))
  3136.                     return (_fieldString);
  3137.                
  3138.                 return (base.GetName(curNS));
  3139.             }
  3140.             internal ArrayList Fields {
  3141.                 get { return _fields; }
  3142.             }
  3143.             internal ArrayList Methods {
  3144.                 get { return _methods; }
  3145.             }
  3146.             internal void AddField(URTField field)
  3147.             {
  3148.                 Util.Log("URTComplexType.AddField");
  3149.                 _fields.Add(field);
  3150.             }
  3151.             internal void AddMethod(URTMethod method)
  3152.             {
  3153.                 Util.Log("URTComplexType.AddMethod " + method);
  3154.                 _methods.Add(method);
  3155.             }
  3156.             private URTMethod GetMethod(string name)
  3157.             {
  3158.                 Util.Log("URTComplexType.GetMethod " + name);
  3159.                 for (int i = 0; i < _methods.Count; i++) {
  3160.                     URTMethod method = (URTMethod)_methods[i];
  3161.                     if (method.Name == name)
  3162.                         return (method);
  3163.                 }
  3164.                
  3165.                 return (null);
  3166.             }
  3167.             internal void ResolveTypes(SdlParser parser)
  3168.             {
  3169.                 Util.Log("URTComplexType.ResolveTypes " + Name + " _baseTypeName " + _baseTypeName + " IsSUDSType " + IsSUDSType);
  3170.                 string baseTypeNS = null;
  3171.                 string baseTypeAssemName = null;
  3172.                 if (_baseTypeName != null) {
  3173.                     Util.Log("URTComplexType.ResolveTypes 1 ");
  3174.                     UrtType urtType = parser.IsURTExportedType(_baseTypeXmlNS, out baseTypeNS, out baseTypeAssemName);
  3175.                     if ((urtType == UrtType.Interop) && baseTypeNS.StartsWith("System")) {
  3176.                         _baseType = new SystemType(_baseTypeName, baseTypeNS, baseTypeAssemName);
  3177.                     }
  3178.                     else {
  3179.                         URTNamespace ns = parser.LookupNamespace(_baseTypeXmlNS);
  3180.                         if (ns == null) {
  3181.                             throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), _baseTypeXmlNS));
  3182.                         }
  3183.                         _baseType = ns.LookupComplexType(_baseTypeName);
  3184.                         if (_baseType == null) {
  3185.                             throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), _baseTypeName, _baseTypeXmlNS));
  3186.                         }
  3187.                     }
  3188.                 }
  3189.                 else if (IsSUDSType) {
  3190.                     Util.Log("URTComplexType.ResolveTypes 2 SUDSType " + ((Enum)_sudsType).ToString());
  3191.                     if (_sudsType == SUDSType.ClientProxy) {
  3192.                         Util.Log("URTComplexType.ResolveTypes 3 ");
  3193.                         _baseTypeName = "RemotingClientProxy";
  3194.                         _baseTypeXmlNS = SoapServices.CodeXmlNamespaceForClrTypeNamespace("System.Runtime.Remoting", "System.Runtime.Remoting");
  3195.                         baseTypeNS = "System.Runtime.Remoting.Services";
  3196.                         baseTypeAssemName = "System.Runtime.Remoting";
  3197.                     }
  3198.                     else if (_sudsType == SUDSType.MarshalByRef) {
  3199.                         Util.Log("URTComplexType.ResolveTypes 4 ");
  3200.                         _baseTypeName = "MarshalByRefObject";
  3201.                         _baseTypeXmlNS = SoapServices.CodeXmlNamespaceForClrTypeNamespace("System", null);
  3202.                         baseTypeNS = "System";
  3203.                         baseTypeAssemName = null;
  3204.                     }
  3205.                     _baseType = new SystemType(_baseTypeName, baseTypeNS, baseTypeAssemName);
  3206.                 }
  3207.                 else {
  3208.                     Util.Log("URTComplexType.ResolveTypes 5 ");
  3209.                     _baseType = new SystemType("Object", "System", null);
  3210.                 }
  3211.                 for (int i = 0; i < _implIFaceNames.Count; i = i + 2) {
  3212.                     string implIFaceName = (string)_implIFaceNames[i];
  3213.                     string implIFaceXmlNS = (string)_implIFaceNames[i + 1];
  3214.                     string implIFaceNS;
  3215.                     string implIFaceAssemName;
  3216.                     BaseInterface iFace;
  3217.                    
  3218.                    
  3219.                     UrtType iType = parser.IsURTExportedType(implIFaceXmlNS, out implIFaceNS, out implIFaceAssemName);
  3220.                    
  3221.                     if ((iType == UrtType.UrtSystem) && implIFaceNS.StartsWith("System")) {
  3222.                         iFace = new SystemInterface(implIFaceName, implIFaceNS);
  3223.                     }
  3224.                     else {
  3225.                         URTNamespace ns = parser.LookupNamespace(implIFaceXmlNS);
  3226.                         if (ns == null) {
  3227.                             throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), implIFaceXmlNS));
  3228.                         }
  3229.                         iFace = ns.LookupInterface(implIFaceName);
  3230.                         if (iFace == null) {
  3231.                             throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), implIFaceName, implIFaceXmlNS));
  3232.                         }
  3233.                     }
  3234.                     _implIFaces.Add(iFace);
  3235.                 }
  3236.                 for (int i = 0; i < _methods.Count; i++)
  3237.                     ((URTMethod)_methods[i]).ResolveTypes(parser);
  3238.             }
  3239.             internal void ResolveMethods()
  3240.             {
  3241.                 Util.Log("URTComplexType.ResolveMethods " + Name);
  3242.                 for (int i = 0; i < _methods.Count; i++) {
  3243.                     URTMethod method = (URTMethod)_methods[i];
  3244.                     if (method.MethodFlags == 0)
  3245.                         method.MethodFlags = _baseType.GetMethodFlags(method) | 1;
  3246.                 }
  3247.                
  3248.                 return;
  3249.             }
  3250.             internal override int GetMethodFlags(URTMethod method)
  3251.             {
  3252.                 Debug.Assert(method.MethodFlags == 0, "Method has already been considered");
  3253.                
  3254.                 int methodFlags = _baseType.GetMethodFlags(method) | 1;
  3255.                 for (int i = 0; i < _methods.Count; i++) {
  3256.                     URTMethod thisMethod = (URTMethod)_methods[i];
  3257.                     if (thisMethod.Equals(method))
  3258.                         thisMethod.MethodFlags = methodFlags | 1;
  3259.                 }
  3260.                
  3261.                 return (methodFlags);
  3262.             }
  3263.             internal void PrintCSC(TextWriter textWriter, string indentation, string curNS, StringBuilder sb)
  3264.             {
  3265.                 Util.Log("URTComplexType.PrintCSC name " + Name + " curNS " + curNS);
  3266.                 // Print only if the type is not an emittable field type
  3267.                 if (IsEmittableFieldType == true)
  3268.                     return;
  3269.                
  3270.                 // Handle delegate case
  3271.                 sb.Length = 0;
  3272.                 sb.Append(indentation);
  3273.                 if (_baseTypeName != null) {
  3274.                     string baseName = _baseType.GetName(curNS);
  3275.                     if ((baseName == "System.Delegate") || (baseName == "System.MulticastDelegate")) {
  3276.                         sb.Append("public delegate ");
  3277.                         URTMethod invokeMethod = GetMethod("Invoke");
  3278.                         if (invokeMethod == null) {
  3279.                             throw new SUDSParserException(CoreChannel.GetResourceString("Remoting_Suds_DelegateWithoutInvoke"));
  3280.                         }
  3281.                         sb.Append(invokeMethod.GetTypeString(curNS));
  3282.                         sb.Append(' ');
  3283.                         sb.Append(Name);
  3284.                         sb.Append('(');
  3285.                         invokeMethod.PrintSignature(sb, curNS);
  3286.                         sb.Append(");");
  3287.                         textWriter.WriteLine(sb);
  3288.                         return;
  3289.                     }
  3290.                 }
  3291.                
  3292.                 bool bURTType = IsURTType;
  3293.                 if (bURTType == false) {
  3294.                     sb.Length = 0;
  3295.                     sb.Append(indentation);
  3296.                     sb.Append("[SoapType(XmlElementName=\"");
  3297.                     sb.Append(ElementName);
  3298.                     sb.Append("\", XmlNamespace=\"");
  3299.                     sb.Append(Namespace);
  3300.                     sb.Append("\", XmlTypeName=\"");
  3301.                     sb.Append(Name);
  3302.                     sb.Append("\", XmlTypeNamespace=\"");
  3303.                     sb.Append(Namespace);
  3304.                     sb.Append("\")]");
  3305.                     textWriter.WriteLine(sb);
  3306.                 }
  3307.                
  3308.                 sb.Length = 0;
  3309.                 sb.Append(indentation);
  3310.                 if (IsStruct == true)
  3311.                     sb.Append("public struct ");
  3312.                 else
  3313.                     sb.Append("public class ");
  3314.                 sb.Append(Name);
  3315.                 if (_baseTypeName != null)
  3316.                     sb.Append(" : ");
  3317.                 bool bBaseIsURTType = true;
  3318.                 if (_baseTypeName != null) {
  3319.                     bBaseIsURTType = _baseType.IsURTType;
  3320.                     string baseString = _baseType.GetName(curNS);
  3321.                     if (baseString == "System.__ComObject") {
  3322.                         /*textWriter.Write(indentation);
  3323.                         textWriter.WriteLine("[guid(\"cc3bf020-1881-4e44-88d8-39b1052b1b11\")]");
  3324.                         textWriter.Write(indentation);
  3325.                         textWriter.WriteLine("[comimport]"); */                       
  3326. sb.Append("System.MarshalByRefObject");
  3327.                     }
  3328.                     else {
  3329.                         sb.Append(baseString);
  3330.                     }
  3331.                 }
  3332.                
  3333.                 if (_implIFaces.Count > 0) {
  3334.                     for (int i = 0; i < _implIFaces.Count; i++) {
  3335.                         sb.Append(", ");
  3336.                         sb.Append(((BaseInterface)_implIFaces[i]).GetName(curNS));
  3337.                     }
  3338.                 }
  3339.                 textWriter.WriteLine(sb);
  3340.                
  3341.                 textWriter.Write(indentation);
  3342.                 textWriter.WriteLine('{');
  3343.                
  3344.                 string newIndentation = indentation + " ";
  3345.                 int newIndentationLength = newIndentation.Length;
  3346.                 //bool fClientProxy = _connectURL != null;
  3347.                
  3348.                 Util.Log("URTComplexType.PrintCSC _sudsType " + ((Enum)_sudsType).ToString());
  3349.                 bool fClientProxy = (_sudsType == SUDSType.ClientProxy);
  3350.                 if (fClientProxy) {
  3351.                     sb.Length = 0;
  3352.                     sb.Append(newIndentation);
  3353.                     sb.Append("// Constructor");
  3354.                     textWriter.WriteLine(sb);
  3355.                    
  3356.                     sb.Length = newIndentationLength;
  3357.                     sb.Append("public ");
  3358.                     sb.Append(Name);
  3359.                     sb.Append("()");
  3360.                     textWriter.WriteLine(sb);
  3361.                    
  3362.                     sb.Length = newIndentationLength;
  3363.                     sb.Append('{');
  3364.                     textWriter.WriteLine(sb);
  3365.                    
  3366.                     if (_connectURLs != null) {
  3367.                         for (int i = 0; i < _connectURLs.Count; i++) {
  3368.                             sb.Length = newIndentationLength;
  3369.                             sb.Append(" ");
  3370.                             if (i == 0) {
  3371.                                 sb.Append("base.ConfigureProxy(this.GetType(), \"");
  3372.                                 sb.Append(_connectURLs[i]);
  3373.                                 sb.Append("\");");
  3374.                             }
  3375.                             else {
  3376.                                 // Only the first location is used, the rest are commented out in the proxy
  3377.                                 sb.Append("//base.ConfigureProxy(this.GetType(), \"");
  3378.                                 sb.Append(_connectURLs[i]);
  3379.                                 sb.Append("\");");
  3380.                             }
  3381.                             textWriter.WriteLine(sb);
  3382.                         }
  3383.                     }
  3384.                    
  3385.                     sb.Length = newIndentationLength;
  3386.                     sb.Append('}');
  3387.                     textWriter.WriteLine(sb);
  3388.                 }
  3389.                
  3390.                 if (_methods.Count > 0) {
  3391.                     textWriter.Write(newIndentation);
  3392.                     textWriter.WriteLine("// Class Methods");
  3393.                     string bodyPrefix = null;
  3394.                     if (fClientProxy) {
  3395.                         sb.Length = 0;
  3396.                         sb.Append("((");
  3397.                         sb.Append(Name);
  3398.                         sb.Append(") _tp).");
  3399.                         bodyPrefix = sb.ToString();
  3400.                     }
  3401.                     for (int i = 0; i < _methods.Count; i++) {
  3402.                         Util.Log("URTComplexType.PrintCSC Invoke methods PrintCSC ");
  3403.                         ((URTMethod)_methods[i]).PrintCSC(textWriter, newIndentation, " ", curNS, true, bURTType, bodyPrefix, sb);
  3404.                     }
  3405.                     textWriter.WriteLine();
  3406.                 }
  3407.                
  3408.                 if (_implIFaces.Count > 0) {
  3409.                     ArrayList printedIFaces = new ArrayList(_implIFaces.Count);
  3410.                     for (int i = 0; i < _implIFaces.Count; i++)
  3411.                         ((BaseInterface)_implIFaces[i]).PrintClassMethods(textWriter, newIndentation, curNS, printedIFaces, fClientProxy, sb);
  3412.                     textWriter.WriteLine();
  3413.                 }
  3414.                
  3415.                 if (_fields.Count > 0) {
  3416.                     textWriter.Write(newIndentation);
  3417.                     textWriter.WriteLine("// Class Fields");
  3418.                     for (int i = 0; i < _fields.Count; i++) {
  3419.                         Util.Log("URTComplexType.PrintCS Invoke _fields PrintCSC");
  3420.                         ((URTField)_fields[i]).PrintCSC(textWriter, newIndentation, curNS, sb);
  3421.                     }
  3422.                 }
  3423.                 // Close class
  3424.                 sb.Length = 0;
  3425.                 sb.Append(indentation);
  3426.                 sb.Append("}");
  3427.                 textWriter.WriteLine(sb);
  3428.                 return;
  3429.             }
  3430.            
  3431.             private string _baseTypeName;
  3432.             private string _baseTypeXmlNS;
  3433.             private BaseType _baseType;
  3434.             private ArrayList _connectURLs;
  3435.             private bool _bStruct;
  3436.             private SchemaBlockType _blockType;
  3437.             private bool _bSUDSType;
  3438.             private bool _bAnonymous;
  3439.             private string _fieldString;
  3440.             private ArrayList _implIFaceNames;
  3441.             private ArrayList _implIFaces;
  3442.             private ArrayList _fields;
  3443.             private ArrayList _methods;
  3444.             private SUDSType _sudsType;
  3445.         }
  3446.        
  3447.         // Represents an XML element declaration
  3448.         internal class ElementDecl
  3449.         {
  3450.             // Constructor
  3451.             public ElementDecl(string elmName, string elmNS, string typeName, string typeNS, bool bPrimitive)
  3452.             {
  3453.                 Util.Log("ElementDecl.ElementDecl elmName " + elmName + " elmNS " + elmNS + " typeName " + typeName + " typeNS " + typeNS + " bPrimitive " + bPrimitive);
  3454.                 _elmName = elmName;
  3455.                 _elmNS = elmNS;
  3456.                 _typeName = typeName;
  3457.                 _typeNS = typeNS;
  3458.                 _bPrimitive = bPrimitive;
  3459.             }
  3460.            
  3461.             // Field accessors
  3462.             public string Name {
  3463.                 get { return (_elmName); }
  3464.             }
  3465.             public string Namespace {
  3466.                 get { return (_elmNS); }
  3467.             }
  3468.             public string TypeName {
  3469.                 get { return (_typeName); }
  3470.             }
  3471.             public string TypeNS {
  3472.                 get { return (_typeNS); }
  3473.             }
  3474.            
  3475.             public void Resolve(SdlParser parser)
  3476.             {
  3477.                 Util.Log("ElementDecl.Resolve " + TypeName + " " + TypeNS);
  3478.                 // Return immediately for element declaration of primitive types
  3479.                 if (_bPrimitive)
  3480.                     return;
  3481.                
  3482.                 // Lookup the type from the element declaration
  3483.                 URTNamespace typeNS = parser.LookupNamespace(TypeNS);
  3484.                 if (typeNS == null) {
  3485.                     throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), TypeNS));
  3486.                 }
  3487.                 BaseType type = typeNS.LookupType(TypeName);
  3488.                 if (type == null) {
  3489.                     throw new SUDSParserException(String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), TypeName, TypeNS));
  3490.                 }
  3491.                
  3492.                 type.ElementName = Name;
  3493.                 type.ElementNS = Namespace;
  3494.                
  3495.                 return;
  3496.             }
  3497.            
  3498.             // Fields
  3499.             private string _elmName;
  3500.             private string _elmNS;
  3501.             private string _typeName;
  3502.             private string _typeNS;
  3503.             private bool _bPrimitive;
  3504.         }
  3505.        
  3506.         // Represents a namespace
  3507.         internal class URTNamespace
  3508.         {
  3509.             // Constructor
  3510.             public URTNamespace(string name, SdlParser parser)
  3511.             {
  3512.                 Util.Log("URTNamespace.URTNamespace name " + name);
  3513.                 _name = name;
  3514.                 _nsType = parser.IsURTExportedType(name, out _namespace, out _assemName);
  3515.                 if (_nsType == UrtType.Interop)
  3516.                     _encodedNS = "InteropProxy";
  3517.                 else
  3518.                     _encodedNS = _namespace;
  3519.                 _elmDecls = new ArrayList();
  3520.                 _URTComplexTypes = new ArrayList();
  3521.                 _numURTComplexTypes = 0;
  3522.                 _URTSimpleTypes = new ArrayList();
  3523.                 _numURTSimpleTypes = 0;
  3524.                 _URTInterfaces = new ArrayList();
  3525.                 _anonymousSeqNum = 0;
  3526.             }
  3527.            
  3528.             // Get the next anonymous type name
  3529.             public string GetNextAnonymousName()
  3530.             {
  3531.                 ++_anonymousSeqNum;
  3532.                 Util.Log("URTNamespace.GetNextAnonymousName AnonymousType" + _anonymousSeqNum + " ComplexType " + _name);
  3533.                 return ("AnonymousType" + _anonymousSeqNum);
  3534.             }
  3535.            
  3536.             // Add a new element declaration to the namespace
  3537.             public void AddElementDecl(ElementDecl elmDecl)
  3538.             {
  3539.                 Util.Log("URTNamespace.AddElementDecl ");
  3540.                 _elmDecls.Add(elmDecl);
  3541.             }
  3542.            
  3543.             // Add a new type into the namespace
  3544.             public void AddComplexType(URTComplexType type)
  3545.             {
  3546.                 Util.Log("URTNamespace.AddComplexType " + type.Name);
  3547.                 // Assert that simple and complex types share the same namespace
  3548.                 Debug.Assert(LookupSimpleType(type.Name) == null, "Complex type has the same name as a simple type");
  3549.                 _URTComplexTypes.Add(type);
  3550.                 ++_numURTComplexTypes;
  3551.             }
  3552.            
  3553.             // Add a new type into the namespace
  3554.             public void AddSimpleType(URTSimpleType type)
  3555.             {
  3556.                 Util.Log("URTNamespace.AddSimpleType " + type.Name);
  3557.                 // Assert that simple and complex types share the same namespace
  3558.                 Debug.Assert(LookupComplexType(type.Name) == null, "Simple type has the same name as a complex type");
  3559.                 _URTSimpleTypes.Add(type);
  3560.                 ++_numURTSimpleTypes;
  3561.             }
  3562.            
  3563.             // Adds a new interface into the namespace
  3564.             public void AddInterface(URTInterface iface)
  3565.             {
  3566.                 Util.Log("URTNamespace.AddInterface " + iface.Name);
  3567.                 _URTInterfaces.Add(iface);
  3568.             }
  3569.            
  3570.             // Returns the namespace
  3571.             public string Namespace {
  3572.                 get { return (_namespace); }
  3573.             }
  3574.            
  3575.             // Returns Encoded namespace
  3576.             public string EncodedNS {
  3577.                 get { return (_encodedNS); }
  3578.             }
  3579.            
  3580.             // Returns the full name
  3581.             public string Name {
  3582.                 get { return (_name); }
  3583.             }
  3584.            
  3585.             // Returns Assembly name
  3586.             public string AssemName {
  3587.                 get { return (_assemName); }
  3588.             }
  3589.            
  3590.             public UrtType UrtType {
  3591.                 get { return _nsType; }
  3592.             }
  3593.            
  3594.             // Returns true if this represents a URTNamespace
  3595.             public bool IsURTNamespace {
  3596.                 get { return ((object)_namespace == (object)_encodedNS); }
  3597.             }
  3598.            
  3599.             // Returns true if the namespace has no types defined
  3600.             public bool IsEmpty {
  3601.                 get {
  3602.                     bool isEmpty = true;
  3603.                     if ((_numURTComplexTypes == 0) && (_URTInterfaces.Count == 0) && (_numURTSimpleTypes == 0))
  3604.                         isEmpty = true;
  3605.                     else
  3606.                         isEmpty = false;
  3607.                    
  3608.                     /*
  3609.                     if (_numURTComplexTypes > 0)
  3610.                     {
  3611.                         for(int i=0;i<_URTComplexTypes.Count;i++)
  3612.                         {
  3613.                             URTComplexType type = (URTComplexType) _URTComplexTypes[i];
  3614.                             if ((type != null) && (!type.IsAnonymous))
  3615.                             {
  3616.                                 isEmpty = false;
  3617.                                 break;
  3618.                             }
  3619.                         }
  3620.                         if (isEmpty)
  3621.                         {
  3622.                             for(int i=0;i<_URTSimpleTypes.Count;i++)
  3623.                             {
  3624.                                 URTSimpleType type = (URTSimpleType) _URTSimpleTypes[i];
  3625.                                 if ((type != null) && (!type.IsAnonymous))
  3626.                                 {
  3627.                                     isEmpty = false;
  3628.                                     break;
  3629.                                 }
  3630.                             }
  3631.                         }
  3632.                     }
  3633.                     */                   
  3634. return isEmpty;
  3635.                 }
  3636.             }
  3637.            
  3638.             // Looks up a element declaration
  3639.             public ElementDecl LookupElementDecl(string name)
  3640.             {
  3641.                 Util.Log("URTNamespace.LookupElementDecl " + name);
  3642.                 for (int i = 0; i < _elmDecls.Count; i++) {
  3643.                     ElementDecl elm = (ElementDecl)_elmDecls[i];
  3644.                     if (elm.Name == name)
  3645.                         return (elm);
  3646.                 }
  3647.                
  3648.                 return (null);
  3649.             }
  3650.            
  3651.             // Looks up a complex type
  3652.             public URTComplexType LookupComplexType(string typeName)
  3653.             {
  3654.                 Util.Log("URTNamespace.LookupComplexType " + typeName);
  3655.                 for (int i = 0; i < _URTComplexTypes.Count; i++) {
  3656.                     URTComplexType type = (URTComplexType)_URTComplexTypes[i];
  3657.                     if ((type != null) && SdlParser.MatchingStrings(type.Name, typeName))
  3658.                         return (type);
  3659.                 }
  3660.                
  3661.                 return (null);
  3662.             }
  3663.            
  3664.             // Looks up a simple type
  3665.             public URTSimpleType LookupSimpleType(string typeName)
  3666.             {
  3667.                 Util.Log("URTNamespace.LookupSimpleType " + typeName);
  3668.                 for (int i = 0; i < _URTSimpleTypes.Count; i++) {
  3669.                     URTSimpleType type = (URTSimpleType)_URTSimpleTypes[i];
  3670.                     if ((type != null) && SdlParser.MatchingStrings(type.Name, typeName))
  3671.                         return (type);
  3672.                 }
  3673.                
  3674.                 return (null);
  3675.             }
  3676.            
  3677.             // Looks up a complex or simple type
  3678.             public BaseType LookupType(string typeName)
  3679.             {
  3680.                 BaseType type = LookupComplexType(typeName);
  3681.                 if (type == null)
  3682.                     type = LookupSimpleType(typeName);
  3683.                
  3684.                 return (type);
  3685.             }
  3686.            
  3687.             // Removes the given type from the namespace
  3688.             public void RemoveComplexType(URTComplexType type)
  3689.             {
  3690.                 Util.Log("URTNamespace.RemoveComplexType " + type.Name + " complex Type " + _name);
  3691.                 for (int i = 0; i < _URTComplexTypes.Count; i++) {
  3692.                     Util.Log("URTNamespace.RemoveComplexType 1 " + type.Name + " complexTypes " + ((_URTComplexTypes[i] != null) ? ((URTComplexType)_URTComplexTypes[i]).Name : "Null"));
  3693.                     if (_URTComplexTypes[i] == type) {
  3694.                         Util.Log("URTNamespace.RemoveComplexType 2 match " + type.Name + " complexTypes " + ((_URTComplexTypes[i] != null) ? ((URTComplexType)_URTComplexTypes[i]).Name : "Null"));
  3695.                         _URTComplexTypes[i] = null;
  3696.                         --_numURTComplexTypes;
  3697.                         return;
  3698.                     }
  3699.                 }
  3700.                
  3701.                 throw new SUDSParserException(CoreChannel.GetResourceString("Remoting_Suds_TriedToRemoveNonexistentType"));
  3702.             }
  3703.            
  3704.             // Removes the given type from the namespace
  3705.             public void RemoveSimpleType(URTSimpleType type)
  3706.             {
  3707.                 Util.Log("URTNamespace.RemoveSimpleType " + type.Name + " SimpleType " + _name);
  3708.                 for (int i = 0; i < _URTSimpleTypes.Count; i++) {
  3709.                     if (_URTSimpleTypes[i] == type) {
  3710.                         _URTSimpleTypes[i] = null;
  3711.                         --_numURTSimpleTypes;
  3712.                         return;
  3713.                     }
  3714.                 }
  3715.                
  3716.                 throw new SUDSParserException(CoreChannel.GetResourceString("Remoting_Suds_TriedToRemoveNonexistentType"));
  3717.             }
  3718.            
  3719.             // Looks up an interface
  3720.             public URTInterface LookupInterface(string iFaceName)
  3721.             {
  3722.                 Util.Log("URTNamespace.LookupInterface " + iFaceName);
  3723.                 for (int i = 0; i < _URTInterfaces.Count; i++) {
  3724.                     URTInterface iFace = (URTInterface)_URTInterfaces[i];
  3725.                     if (SdlParser.MatchingStrings(iFace.Name, iFaceName))
  3726.                         return (iFace);
  3727.                 }
  3728.                
  3729.                 return (null);
  3730.             }
  3731.            
  3732.             // Resolve element references
  3733.             public void ResolveElements(SdlParser parser)
  3734.             {
  3735.                 Util.Log("URTNamespace.ResolveElements " + Name);
  3736.                 for (int i = 0; i < _elmDecls.Count; i++)
  3737.                     ((ElementDecl)_elmDecls[i]).Resolve(parser);
  3738.             }
  3739.            
  3740.             // Resolves internal references
  3741.             public void ResolveTypes(SdlParser parser)
  3742.             {
  3743.                 Util.Log("URTNamespace.ResolveTypes " + Name);
  3744.                 for (int i = 0; i < _URTComplexTypes.Count; i++) {
  3745.                     if (_URTComplexTypes[i] != null)
  3746.                         ((URTComplexType)_URTComplexTypes[i]).ResolveTypes(parser);
  3747.                 }
  3748.                
  3749.                 for (int i = 0; i < _URTInterfaces.Count; i++)
  3750.                     ((URTInterface)_URTInterfaces[i]).ResolveTypes(parser);
  3751.             }
  3752.            
  3753.             // Resolves method types
  3754.             public void ResolveMethods()
  3755.             {
  3756.                 Util.Log("URTNamespace.ResolveMethods " + Name);
  3757.                 for (int i = 0; i < _URTComplexTypes.Count; i++) {
  3758.                     if (_URTComplexTypes[i] != null)
  3759.                         ((URTComplexType)_URTComplexTypes[i]).ResolveMethods();
  3760.                 }
  3761.             }
  3762.            
  3763.             // Prints all the types in the namespace
  3764.             public void PrintCSC(TextWriter textWriter)
  3765.             {
  3766.                 Util.Log("URTNamespace.PrintCSC " + Namespace);
  3767.                 Debug.Assert(!IsEmpty, "Empty namespace " + Name + " being printed");
  3768.                 string indentation = String.Empty;
  3769.                 if ((Namespace != null) && (Namespace.Length != 0)) {
  3770.                     textWriter.Write("namespace ");
  3771.                     textWriter.Write(EncodedNS);
  3772.                     textWriter.WriteLine(" {");
  3773.                     indentation = " ";
  3774.                 }
  3775.                 textWriter.WriteLine("using System;");
  3776.                 textWriter.WriteLine("using System.Runtime.Remoting.Messaging;");
  3777.                 textWriter.WriteLine("using System.Runtime.Remoting.Metadata;");
  3778.                
  3779.                 StringBuilder sb = new StringBuilder(256);
  3780.                 if (_numURTComplexTypes > 0) {
  3781.                     for (int i = 0; i < _URTComplexTypes.Count; i++) {
  3782.                         URTComplexType type = (URTComplexType)_URTComplexTypes[i];
  3783.                         if (type != null) {
  3784.                             Util.Log("URTNamespace.PrintCSC Invoke Complex type PrintCSC");
  3785.                             type.PrintCSC(textWriter, indentation, Namespace, sb);
  3786.                         }
  3787.                     }
  3788.                 }
  3789.                
  3790.                 if (_numURTSimpleTypes > 0) {
  3791.                     for (int i = 0; i < _URTSimpleTypes.Count; i++) {
  3792.                         URTSimpleType type = (URTSimpleType)_URTSimpleTypes[i];
  3793.                         if (type != null) {
  3794.                             Util.Log("URTNamespace.PrintCSC Invoke Simple type PrintCSC");
  3795.                             type.PrintCSC(textWriter, indentation, Namespace, sb);
  3796.                         }
  3797.                     }
  3798.                 }
  3799.                
  3800.                 for (int i = 0; i < _URTInterfaces.Count; i++) {
  3801.                     Util.Log("URTNamespace.PrintCSC Invoke Interfaces PrintCSC");
  3802.                     ((URTInterface)_URTInterfaces[i]).PrintCSC(textWriter, indentation, Namespace, sb);
  3803.                 }
  3804.                
  3805.                 if ((Namespace != null) && (Namespace.Length != 0))
  3806.                     textWriter.WriteLine('}');
  3807.                
  3808.                 return;
  3809.             }
  3810.            
  3811.             // Fields
  3812.             private string _name;
  3813.             private UrtType _nsType;
  3814.             private string _namespace;
  3815.             private string _encodedNS;
  3816.             private string _assemName;
  3817.             private int _anonymousSeqNum;
  3818.             private ArrayList _elmDecls;
  3819.             private ArrayList _URTComplexTypes;
  3820.             private int _numURTComplexTypes;
  3821.             private ArrayList _URTSimpleTypes;
  3822.             private int _numURTSimpleTypes;
  3823.             private ArrayList _URTInterfaces;
  3824.         }
  3825.        
  3826.     }
  3827. }

Developer Fusion