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

  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: WsdlParser.cs
  18. // Purpose: Defines WsdlParser that parses a given WSDL document
  19. // and generates types defined in it.
  20. //
  21. // Date: November 15, 2000
  22. //
  23. //============================================================
  24. namespace System.Runtime.Remoting.MetadataServices
  25. {
  26.     using System;
  27.     using System.Threading;
  28.     using System.Collections;
  29.     using System.Reflection;
  30.     using System.Xml;
  31.     using System.Diagnostics;
  32.     using System.IO;
  33.     using System.Text;
  34.     using System.Net;
  35.     using System.Runtime.Remoting.Channels;
  36.     // This is so we can get the resource strings.
  37.     using System.Runtime.Remoting;
  38.     using System.Globalization;
  39.    
  40.     // This class parses SUDS documents
  41.     internal class WsdlParser
  42.     {
  43.        
  44.         // Main parser
  45.         internal WsdlParser(TextReader input, string outputDir, ArrayList outCodeStreamList, string locationURL, bool bWrappedProxy, string proxyNamespace)
  46.         {
  47.             Util.Log("WsdlParser.WsdlParser outputDir " + outputDir + " locationURL " + locationURL + " bWrappedProxy " + bWrappedProxy + " proxyNamespace " + proxyNamespace);
  48.             // Initialize member variables
  49.             _XMLReader = null;
  50.             _readerStreamsWsdl = new ReaderStream(locationURL);
  51.             _readerStreamsWsdl.InputStream = input;
  52.             _writerStreams = null;
  53.             _outputDir = outputDir;
  54.             _outCodeStreamList = outCodeStreamList;
  55.             _bWrappedProxy = bWrappedProxy;
  56.             if (proxyNamespace == null || proxyNamespace.Length == 0)
  57.                 _proxyNamespace = "InteropNS";
  58.             else
  59.                 _proxyNamespace = proxyNamespace;
  60.             if (outputDir == null)
  61.                 outputDir = ".";
  62.            
  63.             int length = outputDir.Length;
  64.             if (length > 0) {
  65.                 char endChar = outputDir[length - 1];
  66.                 if (endChar != '\\' && endChar != '/')
  67.                     _outputDir = _outputDir + '\\';
  68.             }
  69.             //_namespaceStack = null;
  70.             _URTNamespaces = new ArrayList();
  71.             _blockDefault = SchemaBlockType.ALL;
  72.             _primedNametable = CreatePrimedNametable();
  73.            
  74.         }
  75.        
  76.         internal string SchemaNamespaceString {
  77.             get {
  78.                 string schemaStr = null;
  79.                 switch (_xsdVersion) {
  80.                     case XsdVersion.V1999:
  81.                         schemaStr = s_schemaNamespaceString1999;
  82.                         break;
  83.                     case XsdVersion.V2000:
  84.                         schemaStr = s_schemaNamespaceString2000;
  85.                         break;
  86.                     case XsdVersion.V2001:
  87.                         schemaStr = s_schemaNamespaceString;
  88.                         break;
  89.                 }
  90.                 return schemaStr;
  91.             }
  92.         }
  93.        
  94.         internal string ProxyNamespace {
  95.             get { return _proxyNamespace; }
  96.         }
  97.        
  98.         internal int ProxyNamespaceCount {
  99.             get { return _proxyNamespaceCount; }
  100.             set { _proxyNamespaceCount = value; }
  101.         }
  102.        
  103.         internal XmlTextReader XMLReader {
  104.             get { return _XMLReader; }
  105.         }
  106.        
  107.         // Skips past endtags and non content tags
  108.         private bool SkipXmlElement()
  109.         {
  110.             Util.Log("WsdlParser.SkipXmlElement");
  111.             //PrintNode(Console.Out);
  112.             _XMLReader.Skip();
  113.             XmlNodeType nodeType = _XMLReader.MoveToContent();
  114.             while (nodeType == XmlNodeType.EndElement) {
  115.                 _XMLReader.Read();
  116.                 nodeType = _XMLReader.MoveToContent();
  117.                 if (nodeType == XmlNodeType.None)
  118.                     break;
  119.             }
  120.            
  121.             return (nodeType != XmlNodeType.None);
  122.         }
  123.        
  124.         // Reads past endtags and non content tags
  125.         private bool ReadNextXmlElement()
  126.         {
  127.             Util.Log("WsdlParser.ReadNextXmlElement");
  128.             _XMLReader.Read();
  129.             XmlNodeType nodeType = _XMLReader.MoveToContent();
  130.             while (nodeType == XmlNodeType.EndElement) {
  131.                 _XMLReader.Read();
  132.                 nodeType = _XMLReader.MoveToContent();
  133.                 if (nodeType == XmlNodeType.None)
  134.                     break;
  135.             }
  136.            
  137.             //PrintNode(Console.Out);
  138.             return (nodeType != XmlNodeType.None);
  139.         }
  140.        
  141.         // Parses complex types
  142.         private URTComplexType ParseComplexType(URTNamespace parsingNamespace, string typeName)
  143.         {
  144.             Util.Log("WsdlParser.ParseComplexType NS " + parsingNamespace.Name + " typeName " + typeName);
  145.             // Lookup the name of the type and the base type from which it derives
  146.             if (typeName == null)
  147.                 typeName = LookupAttribute(s_nameString, null, true);
  148.            
  149.             URTNamespace xns = null;
  150.             string typeNS = ParseQName(ref typeName, parsingNamespace, out xns);
  151.            
  152.             Util.Log("WsdlParser.ParseComplexType actualNS 1 " + xns);
  153.             Util.Log("WsdlParser.ParseComplexType actualNS 2 " + xns.Name);
  154.             URTComplexType parsingComplexType = xns.LookupComplexType(typeName);
  155.             if (parsingComplexType == null) {
  156.                 parsingComplexType = new URTComplexType(typeName, xns.Name, xns.Namespace, xns.EncodedNS, _blockDefault, false, typeName != null, this, xns);
  157.                 xns.AddComplexType(parsingComplexType);
  158.             }
  159.            
  160.             string baseType = LookupAttribute(s_baseString, null, false);
  161.            
  162.             if (!MatchingStrings(baseType, s_emptyString)) {
  163.                 string baseNS = ParseQName(ref baseType, parsingNamespace);
  164.                 parsingComplexType.Extends(baseType, baseNS);
  165.             }
  166.            
  167.             if (parsingComplexType.Fields.Count > 0) {
  168.                 SkipXmlElement();
  169.             }
  170.             else {
  171.                 int curDepth = _XMLReader.Depth;
  172.                 ReadNextXmlElement();
  173.                
  174.                 int fieldNum = 0;
  175.                 string elementName;
  176.                 while (_XMLReader.Depth > curDepth) {
  177.                     elementName = _XMLReader.LocalName;
  178.                     if (MatchingStrings(elementName, s_elementString)) {
  179.                         ParseElementField(xns, parsingComplexType, fieldNum);
  180.                         ++fieldNum;
  181.                         continue;
  182.                     }
  183.                     else if (MatchingStrings(elementName, s_attributeString)) {
  184.                         ParseAttributeField(xns, parsingComplexType);
  185.                         continue;
  186.                     }
  187.                     else if (MatchingStrings(elementName, s_allString)) {
  188.                         parsingComplexType.BlockType = SchemaBlockType.ALL;
  189.                     }
  190.                     else if (MatchingStrings(elementName, s_sequenceString)) {
  191.                         parsingComplexType.BlockType = SchemaBlockType.SEQUENCE;
  192.                     }
  193.                     else if (MatchingStrings(elementName, s_choiceString)) {
  194.                         parsingComplexType.BlockType = SchemaBlockType.CHOICE;
  195.                     }
  196.                     else if (MatchingStrings(elementName, s_complexContentString)) {
  197.                         parsingComplexType.BlockType = SchemaBlockType.ComplexContent;
  198.                     }
  199.                     else if (MatchingStrings(elementName, s_restrictionString)) {
  200.                         ParseRestrictionField(xns, parsingComplexType);
  201.                         //++fieldNum;
  202.                         continue;
  203.                     }
  204.                     else {
  205.                         // Ignore others elements such as annotations
  206.                         SkipXmlElement();
  207.                         continue;
  208.                     }
  209.                    
  210.                     // Read next element
  211.                     ReadNextXmlElement();
  212.                 }
  213.             }
  214.            
  215.             return (parsingComplexType);
  216.         }
  217.        
  218.         // Parses simple types
  219.         private URTSimpleType ParseSimpleType(URTNamespace parsingNamespace, string typeName)
  220.         {
  221.             Util.Log("WsdlParser.ParseSimpleType NS " + parsingNamespace + " typeName " + typeName);
  222.             // Lookup the name of the type and the base type from which it derives
  223.             if (typeName == null)
  224.                 typeName = LookupAttribute(s_nameString, null, true);
  225.             string enumType = LookupAttribute(s_enumTypeString, s_wsdlSudsNamespaceString, false);
  226.             URTSimpleType parsingSimpleType = parsingNamespace.LookupSimpleType(typeName);
  227.             if (parsingSimpleType == null) {
  228.                 parsingSimpleType = new URTSimpleType(typeName, parsingNamespace.Name, parsingNamespace.Namespace, parsingNamespace.EncodedNS, typeName != null, this);
  229.                 string baseType = LookupAttribute(s_baseString, null, false);
  230.                 if (!MatchingStrings(baseType, s_emptyString)) {
  231.                     string baseNS = ParseQName(ref baseType, parsingNamespace);
  232.                     parsingSimpleType.Extends(baseType, baseNS);
  233.                 }
  234.                 parsingNamespace.AddSimpleType(parsingSimpleType);
  235.                
  236.                 int curDepth = _XMLReader.Depth;
  237.                 ReadNextXmlElement();
  238.                
  239.                 //int enumFacetNum = 0;
  240.                 string elementName;
  241.                 while (_XMLReader.Depth > curDepth) {
  242.                     elementName = _XMLReader.LocalName;
  243.                    
  244.                     if (MatchingStrings(elementName, s_restrictionString)) {
  245.                         ParseRestrictionField(parsingNamespace, parsingSimpleType);
  246.                     }
  247.                     else/*
  248.                     else if (MatchingStrings(elementName, s_encodingString))
  249.                     {
  250.                         ParseEncoding(parsingSimpleType);
  251.                     }
  252.                     */                   
  253. {
  254.                         SkipXmlElement();
  255.                     }
  256.                 }
  257.             }
  258.             else {
  259.                 SkipXmlElement();
  260.             }
  261.             if (enumType != null)
  262.                 parsingSimpleType.EnumType = enumType;
  263.            
  264.             return (parsingSimpleType);
  265.         }
  266.        
  267. /*
  268.         // Parses encoding
  269.         private void ParseEncoding(URTSimpleType parsingSimpleType)
  270.         {
  271.             Util.Log("WsdlParser.ParseEncoding URTSimpleType "+parsingSimpleType);                                             
  272.             if (_XMLReader.IsEmptyElement == true)
  273.             {
  274.                 // Get the encoding value
  275.                 String valueString = LookupAttribute(s_valueString, null, true);
  276.                 parsingSimpleType.Encoding = valueString;
  277.             }
  278.             else
  279.             {
  280.                 throw new SUDSParserException(
  281.                                             CoreChannel.GetResourceString("Remoting_Suds_EncodingMustBeEmpty"));
  282.             }
  283.             ReadNextXmlElement();
  284.             return;
  285.         }
  286.         */       
  287.        
  288.         // Parses enumeration
  289.         private void ParseEnumeration(URTSimpleType parsingSimpleType, int enumFacetNum)
  290.         {
  291.             Util.Log("WsdlParser.ParseEnumeration facitNum " + enumFacetNum);
  292.             if (_XMLReader.IsEmptyElement == true) {
  293.                 // Get the enum value
  294.                 string valueString = LookupAttribute(s_valueString, null, true);
  295.                 parsingSimpleType.IsEnum = true;
  296.                 parsingSimpleType.AddFacet(new EnumFacet(valueString, enumFacetNum));
  297.             }
  298.             else {
  299.                 throw new SUDSParserException(CoreChannel.GetResourceString("Remoting_Suds_EnumMustBeEmpty"));
  300.             }
  301.             return;
  302.         }
  303.        
  304.        
  305.         // Parses element fields
  306.         private void ParseElementField(URTNamespace parsingNamespace, URTComplexType parsingComplexType, int fieldNum)
  307.         {
  308.             Util.Log("WsdlParser.ParseElementField NS " + parsingNamespace + " fieldNum " + fieldNum);
  309.             // Determine the field name
  310.             string fieldTypeName;
  311.             string fieldTypeXmlNS;
  312.             string fieldName = LookupAttribute(s_nameString, null, true);
  313.            
  314.             // Look for array bounds
  315.             string minOccurs = LookupAttribute(s_minOccursString, null, false);
  316.             string maxOccurs = LookupAttribute(s_maxOccursString, null, false);
  317.            
  318.             // Check if the field is optional
  319.             bool bOptional = false;
  320.             if (MatchingStrings(minOccurs, s_zeroString))
  321.                 bOptional = true;
  322.            
  323.             // Check if the field is an inline array
  324.             bool bArray = false;
  325.             string arraySize = null;
  326.             if (!MatchingStrings(maxOccurs, s_emptyString) && !MatchingStrings(maxOccurs, s_oneString)) {
  327.                 if (MatchingStrings(maxOccurs, s_unboundedString))
  328.                     arraySize = String.Empty;
  329.                 else
  330.                     arraySize = maxOccurs;
  331.                 bArray = true;
  332.             }
  333.            
  334.             // Handle anonymous types
  335.             bool bEmbedded;
  336.             bool bPrimitive;
  337.             if (_XMLReader.IsEmptyElement == true) {
  338.                 // Non-anonymous type case
  339.                 fieldTypeName = LookupAttribute(s_typeString, null, false);
  340.                
  341.                 // Handle the absense of type attribute (Object case)
  342.                 ResolveTypeAttribute(ref fieldTypeName, out fieldTypeXmlNS, out bEmbedded, out bPrimitive);
  343.                
  344.                 // Read next element
  345.                 ReadNextXmlElement();
  346.             }
  347.             else {
  348.                 // Anonymous type case
  349.                 fieldTypeXmlNS = parsingNamespace.Namespace;
  350.                 fieldTypeName = parsingNamespace.GetNextAnonymousName();
  351.                 bPrimitive = false;
  352.                 bEmbedded = true;
  353.                 int curDepth = _XMLReader.Depth;
  354.                 ReadNextXmlElement();
  355.                
  356.                 // Parse the type
  357.                 string elementName;
  358.                 while (_XMLReader.Depth > curDepth) {
  359.                     elementName = _XMLReader.LocalName;
  360.                     if (MatchingStrings(elementName, s_complexTypeString)) {
  361.                         URTComplexType complexType = ParseComplexType(parsingNamespace, fieldTypeName);
  362.                         if (complexType.IsEmittableFieldType) {
  363.                             fieldTypeXmlNS = complexType.FieldNamespace;
  364.                             fieldTypeName = complexType.FieldName;
  365.                             bPrimitive = complexType.PrimitiveField;
  366.                             parsingNamespace.RemoveComplexType(complexType);
  367.                         }
  368.                     }
  369.                     else if (MatchingStrings(elementName, s_simpleTypeString)) {
  370.                         URTSimpleType simpleType = ParseSimpleType(parsingNamespace, fieldTypeName);
  371.                         if (simpleType.IsEmittableFieldType) {
  372.                             fieldTypeXmlNS = simpleType.FieldNamespace;
  373.                             fieldTypeName = simpleType.FieldName;
  374.                             bPrimitive = simpleType.PrimitiveField;
  375.                             parsingNamespace.RemoveSimpleType(simpleType);
  376.                         }
  377.                     }
  378.                     else {
  379.                         // Ignore others elements such as annotations
  380.                         SkipXmlElement();
  381.                     }
  382.                 }
  383.             }
  384.            
  385.             // Add field to the type being parsed
  386.             parsingComplexType.AddField(new URTField(fieldName, fieldTypeName, fieldTypeXmlNS, this, bPrimitive, bEmbedded, false, bOptional, bArray, arraySize,
  387.             parsingNamespace));
  388.             return;
  389.         }
  390.        
  391.         // Parses attribute fields
  392.         private void ParseAttributeField(URTNamespace parsingNamespace, URTComplexType parsingComplexType)
  393.         {
  394.             Util.Log("WsdlParser.ParseAttributeField NS " + parsingNamespace);
  395.             // Lookup field name
  396.             string attrTypeName;
  397.             string attrTypeNS;
  398.             string attrName = LookupAttribute(s_nameString, null, true);
  399.            
  400.             // Check if the field is optional
  401.             bool bOptional = false;
  402.             string minOccurs = LookupAttribute(s_minOccursString, null, false);
  403.             if (MatchingStrings(minOccurs, s_zeroString))
  404.                 bOptional = true;
  405.            
  406.             // Handle anonymous types
  407.             bool bEmbedded;
  408.             bool bPrimitive;
  409.             if (_XMLReader.IsEmptyElement == true) {
  410.                 // Non-anonymous type case and type has to present
  411.                 attrTypeName = LookupAttribute(s_typeString, null, true);
  412.                 ResolveTypeAttribute(ref attrTypeName, out attrTypeNS, out bEmbedded, out bPrimitive);
  413.                
  414.                 // Read next element
  415.                 ReadNextXmlElement();
  416.                
  417.                 // Check for xsd:ID type
  418.                 if (MatchingStrings(attrTypeName, s_idString) && MatchingSchemaStrings(attrTypeNS)) {
  419.                     parsingComplexType.IsStruct = false;
  420.                     return;
  421.                 }
  422.             }
  423.             else {
  424.                 // Anonymous type case
  425.                 attrTypeNS = parsingNamespace.Namespace;
  426.                 attrTypeName = parsingNamespace.GetNextAnonymousName();
  427.                 bPrimitive = false;
  428.                 bEmbedded = true;
  429.                 int curDepth = _XMLReader.Depth;
  430.                 ReadNextXmlElement();
  431.                
  432.                 // Parse the type
  433.                 string elementName;
  434.                 while (_XMLReader.Depth > curDepth) {
  435.                     elementName = _XMLReader.LocalName;
  436.                     if (MatchingStrings(elementName, s_simpleTypeString)) {
  437.                         URTSimpleType simpleType = ParseSimpleType(parsingNamespace, attrTypeName);
  438.                         if (simpleType.IsEmittableFieldType) {
  439.                             attrTypeNS = simpleType.FieldNamespace;
  440.                             attrTypeName = simpleType.FieldName;
  441.                             bPrimitive = simpleType.PrimitiveField;
  442.                             parsingNamespace.RemoveSimpleType(simpleType);
  443.                         }
  444.                     }
  445.                     else {
  446.                         // Ignore others elements such as annotations
  447.                         SkipXmlElement();
  448.                     }
  449.                 }
  450.             }
  451.            
  452.             // Add field to the type being parsed
  453.             parsingComplexType.AddField(new URTField(attrName, attrTypeName, attrTypeNS, this, bPrimitive, bEmbedded, true, bOptional, false, null,
  454.             parsingNamespace));
  455.             return;
  456.         }
  457.        
  458.        
  459.         // Parses RestrictionField fields
  460.         // Now only set up to recognize arrays
  461.         private void ParseRestrictionField(URTNamespace parsingNamespace, BaseType parsingType)
  462.         {
  463.             Util.Log("WsdlParser.ParseRestrictionField Enter NS " + parsingNamespace + " type " + parsingType);
  464.             // Lookup field name
  465.            
  466.             string attrName = LookupAttribute(s_baseString, null, true);
  467.             string baseNS = ParseQName(ref attrName, parsingNamespace);
  468.             //if (MatchingStrings(baseNS, s_soapEncodingString) && MatchingStrings(attrName, s_arrayString))
  469.             {
  470.                 int curDepth = _XMLReader.Depth;
  471.                 ReadNextXmlElement();
  472.                
  473.                 // Parse the type
  474.                 string elementName;
  475.                 string arrayNS;
  476.                 string arrayType;
  477.                 int enumFacetNum = 0;
  478.                 while (_XMLReader.Depth > curDepth) {
  479.                     elementName = _XMLReader.LocalName;
  480.                     Util.Log("WsdlParser.ParseRestrictionField elementName " + elementName);
  481.                     if (MatchingStrings(elementName, s_attributeString)) {
  482.                         string refValue = LookupAttribute(s_refString, null, true);
  483.                         string refNS = ParseQName(ref refValue, parsingNamespace);
  484.                         if (MatchingStrings(refNS, s_soapEncodingString) && MatchingStrings(refValue, s_arrayTypeString)) {
  485.                             URTComplexType parsingComplexType = (URTComplexType)parsingType;
  486.                             arrayType = LookupAttribute(s_arrayTypeString, s_wsdlNamespaceString, true);
  487.                             Util.Log("WsdlParser.ParseRestrictionField arrayType " + arrayType);
  488.                             URTNamespace arrayNamespace = null;
  489.                             arrayNS = ParseQName(ref arrayType, null, out arrayNamespace);
  490.                            
  491.                             parsingComplexType.AddArray(arrayType, arrayNamespace);
  492.                             //Add array to the array namespace
  493.                             arrayNamespace.AddComplexType(parsingComplexType);
  494.                             parsingComplexType.IsPrint = false;
  495.                         }
  496.                     }
  497.                     else if (MatchingStrings(elementName, s_enumerationString)) {
  498.                         URTSimpleType parsingSimpleType = (URTSimpleType)parsingType;
  499.                         ParseEnumeration(parsingSimpleType, enumFacetNum);
  500.                         ++enumFacetNum;
  501.                     }
  502.                     else {
  503.                         // Ignore others elements such as annotations
  504.                         SkipXmlElement();
  505.                     }
  506.                     ReadNextXmlElement();
  507.                 }
  508.             }
  509.             // else
  510.             // SkipXmlElement();
  511.            
  512.             Util.Log("WsdlParser.ParseRestrictionField Exit NS " + parsingNamespace + " type " + parsingType);
  513.             return;
  514.         }
  515.        
  516.        
  517.         // Parses a global element declaration
  518.         private void ParseElementDecl(URTNamespace parsingNamespace)
  519.         {
  520.             Util.Log("WsdlParser.ParseElementDecl");
  521.             // Obtain element name and its type
  522.             string elmName = LookupAttribute(s_nameString, null, true);
  523.             string elmNS = parsingNamespace.Name;
  524.             string typeName = LookupAttribute(s_typeString, null, false);
  525.            
  526.             // Handle the anonymous types
  527.             string typeNS;
  528.             bool bEmbedded;
  529.             bool bPrimitive;
  530.             if (_XMLReader.IsEmptyElement == true) {
  531.                 // Non-anonymous type case
  532.                 // We cannot assert that the type attribute must have been present
  533.                 // due to the Object/ur-type case
  534.                 ResolveTypeAttribute(ref typeName, out typeNS, out bEmbedded, out bPrimitive);
  535.                
  536.                 // Position to the next element
  537.                 ReadNextXmlElement();
  538.             }
  539.             else {
  540.                 // Anonymous type case
  541.                 typeNS = parsingNamespace.Name;
  542.                 typeName = parsingNamespace.GetNextAnonymousName();
  543.                 bEmbedded = true;
  544.                 bPrimitive = false;
  545.                
  546.                 // Parse the type
  547.                 int curDepth = _XMLReader.Depth;
  548.                 ReadNextXmlElement();
  549.                 string elementName;
  550.                 while (_XMLReader.Depth > curDepth) {
  551.                     elementName = _XMLReader.LocalName;
  552.                     if (MatchingStrings(elementName, s_complexTypeString)) {
  553.                         ParseComplexType(parsingNamespace, typeName);
  554.                     }
  555.                     else if (MatchingStrings(elementName, s_simpleTypeString)) {
  556.                         ParseSimpleType(parsingNamespace, typeName);
  557.                     }
  558.                     else {
  559.                         // Ignore others elements such as annotations
  560.                         SkipXmlElement();
  561.                     }
  562.                 }
  563.             }
  564.            
  565.             // Create a new global element under the current namespace
  566.             parsingNamespace.AddElementDecl(new ElementDecl(elmName, elmNS, typeName, typeNS, bPrimitive));
  567.            
  568.             return;
  569.         }
  570.        
  571.         // Checks for reference and array types and resolves to
  572.         // actual types. It returns true if the type needs [Embedded] attribute
  573.         private void ResolveTypeNames(ref string typeNS, ref string typeName, out bool bEmbedded, out bool bPrimitive)
  574.         {
  575.             Util.Log("WsdlParser.ResolveTypeNames typeNS " + typeNS + " typeName " + typeName);
  576.             // Check for reference and array types
  577.             bEmbedded = true;
  578.             bool bArrayType = false;
  579.             if (MatchingStrings(typeNS, s_wsdlSoapNamespaceString)) {
  580.                 if (MatchingStrings(typeName, s_referenceString))
  581.                     bEmbedded = false;
  582.                 else if (MatchingStrings(typeName, s_arrayString))
  583.                     bArrayType = true;
  584.             }
  585.            
  586.             Util.Log("WsdlParser.ResolveTypeNames typeNS 1 bEmbedded " + bEmbedded + " bArrayType " + bArrayType);
  587.             // Resolve to the actual type in the case of reference and array types
  588.             if ((bEmbedded == false) || (bArrayType == true)) {
  589.                 typeName = LookupAttribute(s_refTypeString, s_wsdlSudsNamespaceString, true);
  590.                 typeNS = ParseQName(ref typeName);
  591.             }
  592.            
  593.             // Primitive types do not need the [Embedded] attribute;
  594.             bPrimitive = IsPrimitiveType(typeNS, typeName);
  595.             if (bPrimitive) {
  596.                 typeName = MapSchemaTypesToCSharpTypes(typeName);
  597.                 bEmbedded = false;
  598.             }
  599.             else if (MatchingStrings(typeName, s_urTypeString) && MatchingSchemaStrings(typeNS)) {
  600.                 typeName = s_objectString;
  601.             }
  602.            
  603.             return;
  604.         }
  605.        
  606.         // Parses namespace declaration elements
  607.         private URTNamespace ParseNamespace()
  608.         {
  609.             Util.Log("WsdlParser.ParseNamespace");
  610.             // Determine the new namespace encountered
  611.             string name = (string)LookupAttribute(s_targetNamespaceString, null, false);
  612.             bool bUnique = false;
  613.             if (MatchingStrings(name, s_emptyString) && MatchingStrings(_XMLReader.LocalName, s_sudsString) && _parsingInput.UniqueNS == null) {
  614.                 name = _parsingInput.TargetNS;
  615.                 bUnique = true;
  616.             }
  617.            
  618.             // Add the namespace being parsed to the list if neccessary
  619.             URTNamespace parsingNamespace = LookupNamespace(name);
  620.             if (parsingNamespace == null) {
  621.                 parsingNamespace = new URTNamespace(name, this);
  622.             }
  623.             if (bUnique)
  624.                 _parsingInput.UniqueNS = parsingNamespace;
  625.             //_namespaceStack = NamespaceStack.Push(_namespaceStack, _parsingNamespace, _XMLReader.Depth);
  626.            
  627.             // Parse schema defaults
  628.             //if(MatchingStrings(_XMLReader.LocalName, s_sudsString))
  629.             //{
  630.            
  631.             //}
  632.            
  633.             // Read the next record
  634.             ReadNextXmlElement();
  635.            
  636.             return (parsingNamespace);
  637.         }
  638.        
  639.        
  640.         private void ParseReaderStreamLocation(ReaderStream reader, ReaderStream currentReaderStream)
  641.         {
  642.             Util.Log("WsdlParser.ParseReaderStreamLocation location " + reader.Location + " current location " + currentReaderStream.Location);
  643.             string location = reader.Location;
  644.             int index = location.IndexOf(':');
  645.             if (index == -1) {
  646.                 // relative path
  647.                 if (currentReaderStream == null || currentReaderStream.Location == null)
  648.                     throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_Import"), reader.Location));
  649.                
  650.                 if (currentReaderStream.Uri == null)
  651.                     currentReaderStream.Uri = new Uri(currentReaderStream.Location);
  652.                 // If relative path, will already be changed to absolute path by next statement in previous invocation.
  653.                 Uri uri = new Uri(currentReaderStream.Uri, location);
  654.                 reader.Uri = uri;
  655.                 location = uri.ToString();
  656.                 index = location.IndexOf(':');
  657.                 if (index == -1)
  658.                     return;
  659.                 reader.Location = location;
  660.             }
  661.            
  662.             string protocol = location.Substring(0, index).ToLower(CultureInfo.InvariantCulture);
  663.             string value = location.Substring(index + 1);
  664.             if (protocol == "file") {
  665.                 //Console.WriteLine("Loading file:" + value);
  666.                 reader.InputStream = new StreamReader(value);
  667.             }
  668.             else if (protocol.StartsWith("http", StringComparison.Ordinal)) {
  669.                 Util.Log("WsdlParser.ParseReaderStreamLocation http " + location);
  670.                 WebRequest request = WebRequest.Create(location);
  671.                 WebResponse response = request.GetResponse();
  672.                 Stream responseStream = response.GetResponseStream();
  673.                 reader.InputStream = new StreamReader(responseStream);
  674.             }
  675.         }
  676.        
  677.         private void ParseImport()
  678.         {
  679.             Util.Log("WsdlParser.ParseImport");
  680.             string ns = LookupAttribute(s_namespaceString, null, true);
  681.             string location = null;
  682.             location = LookupAttribute(s_locationString, null, false);
  683.             //wsdl
  684.             Util.Log("WsdlParser.ParseImport " + ns + " location " + location);
  685.             if (location != null && location.Length > 0) {
  686.                 ReaderStream reader = new ReaderStream(location);
  687.                 ParseReaderStreamLocation(reader, (ReaderStream)_currentReaderStack.Peek());
  688.                 ReaderStream.GetReaderStream(_readerStreamsWsdl, reader);
  689.             }
  690.             ReadNextXmlElement();
  691.             return;
  692.         }
  693.        
  694.         internal void Parse()
  695.         {
  696.             Util.Log("WsdlParser.Parse");
  697.             //XmlNameTable primedNametable = CreatePrimedNametable();
  698.             ReaderStream input = _readerStreamsWsdl;
  699.             do {
  700.                 // Initialize the parser
  701.                 _XMLReader = new XmlTextReader(input.InputStream, _primedNametable);
  702.                 _XMLReader.WhitespaceHandling = WhitespaceHandling.None;
  703.                 _XMLReader.XmlResolver = null;
  704.                 ParseInput(input);
  705.                 input = ReaderStream.GetNextReaderStream(input);
  706.             }
  707.             while (input != null);
  708.            
  709.             StartWsdlResolution();
  710.            
  711.             if (null != _writerStreams) {
  712.                 WriterStream.Close(_writerStreams);
  713.             }
  714.            
  715.             return;
  716.         }
  717.        
  718.         // Starts the parser
  719.         private void ParseInput(ReaderStream input)
  720.         {
  721.             Util.Log("WsdlParser.ParseInput" + input.Location);
  722.             _parsingInput = input;
  723.             try {
  724.                 ReadNextXmlElement();
  725.                 string elementName = _XMLReader.LocalName;
  726.                 if (MatchingNamespace(s_wsdlNamespaceString) && MatchingStrings(elementName, s_definitionsString)) {
  727.                     Util.Log("WsdlParser.ParseInput before ParseWsdl " + input.Location);
  728.                     _currentReaderStack.Push(input);
  729.                     // need this to get the base url for relative import elements.
  730.                     ParseWsdl();
  731.                     _currentReaderStack.Pop();
  732.                     // need this to get the base url for relative import elements.
  733.                 }
  734.                 else if (MatchingNamespace(s_wsdlNamespaceString) && MatchingStrings(elementName, s_typesString)) {
  735.                     Util.Log("WsdlParser.ParseInput before ParseWsdlTypes " + input.Location);
  736.                     _currentReaderStack.Push(input);
  737.                     // need this to get the base url for relative import elements.
  738.                     ParseWsdlTypes();
  739.                     _currentReaderStack.Pop();
  740.                     // need this to get the base url for relative import elements.
  741.                 }
  742.                
  743.                 else if (MatchingSchemaNamespace() && MatchingStrings(elementName, s_schemaString)) {
  744.                     Util.Log("WsdlParser.ParseInput before ParseWsdl " + input.Location);
  745.                     _currentReaderStack.Push(input);
  746.                     // need this to get the base url for relative import elements.
  747.                     ParseSchema();
  748.                     _currentReaderStack.Pop();
  749.                     // need this to get the base url for relative import elements.
  750.                 }
  751.                 else
  752.                     throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_UnknownElementAtRootLevel"), elementName));
  753.             }
  754.             finally {
  755.                 WriterStream.Flush(_writerStreams);
  756.             }
  757.         }
  758.        
  759.         private void ParseWsdl()
  760.         {
  761.             Util.Log("WsdlParser.ParseWsdl elementName " + _XMLReader.LocalName + " namespace " + _XMLReader.NamespaceURI);
  762.             int curDepth = _XMLReader.Depth;
  763.             _parsingInput.Name = LookupAttribute(s_nameString, null, false);
  764.             _parsingInput.TargetNS = LookupAttribute(s_targetNamespaceString, null, false);
  765.            
  766.             URTNamespace parsingNamespace = ParseNamespace();
  767.            
  768.             //ReadNextXmlElement();
  769.             while (_XMLReader.Depth > curDepth) {
  770.                 string elementName = _XMLReader.LocalName;
  771.                 Util.Log("WsdlParser.ParseWsdl Loop " + _XMLReader.LocalName);
  772.                 if (MatchingNamespace(s_wsdlNamespaceString)) {
  773.                     if (MatchingStrings(elementName, s_typesString)) {
  774.                         ParseWsdlTypes();
  775.                         continue;
  776.                     }
  777.                     else if (MatchingStrings(elementName, s_messageString)) {
  778.                         ParseWsdlMessage();
  779.                         continue;
  780.                     }
  781.                     else if (MatchingStrings(elementName, s_portTypeString)) {
  782.                         ParseWsdlPortType();
  783.                         continue;
  784.                     }
  785.                     else if (MatchingStrings(elementName, s_bindingString)) {
  786.                         ParseWsdlBinding(parsingNamespace);
  787.                         continue;
  788.                     }
  789.                     else if (MatchingStrings(elementName, s_serviceString)) {
  790.                         ParseWsdlService();
  791.                         continue;
  792.                     }
  793.                     else if (MatchingStrings(elementName, s_importString)) {
  794.                         ParseImport();
  795.                         continue;
  796.                     }
  797.                 }
  798.                 // Ignore others elements such as annotations
  799.                 SkipXmlElement();
  800.             }
  801.            
  802.            
  803.         }
  804.        
  805.         private void StartWsdlResolution()
  806.         {
  807.             Util.Log("WsdlParser.StartWsdlResolution ");
  808.             DumpWsdl();
  809.             ResolveWsdl();
  810.             Resolve();
  811.             PruneNamespaces();
  812.             Util.Log("WsdlParser.ParseWsdl Invoke PrintCSC");
  813.             PrintCSC();
  814.         }
  815.        
  816.         // Since the Wsdl can contains binding sections which are not Rcp,Soap, Encoded. Prune the namespaces from messages etc
  817.         // which are not directly referenced by the Soap binding sections.
  818.         private void PruneNamespaces()
  819.         {
  820.             Util.Log("WsdlParser.PruneNamespaces");
  821.             ArrayList tempList = new ArrayList(10);
  822.             for (int i = 0; i < _URTNamespaces.Count; i++) {
  823.                 URTNamespace urtNS = (URTNamespace)_URTNamespaces[i];
  824.                 if (urtNS.bReferenced)
  825.                     tempList.Add(urtNS);
  826.             }
  827.            
  828.             _URTNamespaces = tempList;
  829.         }
  830.        
  831.         [System.Diagnostics.Conditional("_LOGGING")]
  832.         private void DumpWsdl()
  833.         {
  834.             foreach (DictionaryEntry d in wsdlMessages)
  835.                 ((IDump)d.Value).Dump();
  836.             foreach (DictionaryEntry d in wsdlPortTypes)
  837.                 ((IDump)d.Value).Dump();
  838.             foreach (WsdlBinding item in wsdlBindings)
  839.                 item.Dump();
  840.             foreach (WsdlService item in wsdlServices)
  841.                 item.Dump();
  842.         }
  843.        
  844.         private void ParseWsdlTypes()
  845.         {
  846.             Util.Log("WsdlParser.ParseWsdlTypes");
  847.             int curDepth = _XMLReader.Depth;
  848.             ReadNextXmlElement();
  849.            
  850.             // Initialize mechanism to support xsd import statements;
  851.             _currentSchemaReaderStack.Push(_currentReaderStack.Peek());
  852.             // put current wsdl location as xsd location
  853.             while (_XMLReader.Depth > curDepth) {
  854.                 string elementName = _XMLReader.LocalName;
  855.                 if (MatchingSchemaNamespace()) {
  856.                     if (MatchingStrings(elementName, s_schemaString)) {
  857.                         ParseSchema();
  858.                         if (_readerStreamsXsd != null) {
  859.                             // import element appeared in schema
  860.                             ParseImportedSchemaController();
  861.                         }
  862.                        
  863.                         continue;
  864.                     }
  865.                 }
  866.                
  867.                 // Ignore others elements such as annotations
  868.                 SkipXmlElement();
  869.             }
  870.             _currentSchemaReaderStack.Pop();
  871.         }
  872.        
  873.        
  874.         private void ParseSchemaIncludeElement()
  875.         {
  876.             ParseSchemaImportElement(false);
  877.         }
  878.        
  879.         private void ParseSchemaImportElement()
  880.         {
  881.             ParseSchemaImportElement(true);
  882.         }
  883.        
  884.        
  885.         // Processes an import statement in an xsd schema.
  886.         private void ParseSchemaImportElement(bool bImport)
  887.         {
  888.             Util.Log("WsdlParser.ParseSchemaImportElement IsImport " + bImport);
  889.             string ns = null;
  890.             if (bImport)
  891.                 ns = LookupAttribute(s_namespaceString, null, true);
  892.             string location = null;
  893.             location = LookupAttribute(s_schemaLocationString, null, false);
  894.            
  895.             Util.Log("WsdlParser.ParseSchemaImportElement " + ns + " location " + location);
  896.             if (location != null && location.Length > 0) {
  897.                 if (_readerStreamsXsd == null) {
  898.                     _readerStreamsXsd = new ReaderStream(location);
  899.                     ParseReaderStreamLocation(_readerStreamsXsd, (ReaderStream)_currentSchemaReaderStack.Peek());
  900.                 }
  901.                 else {
  902.                     ReaderStream reader = new ReaderStream(location);
  903.                     ParseReaderStreamLocation(reader, (ReaderStream)_currentSchemaReaderStack.Peek());
  904.                     ReaderStream.GetReaderStream(_readerStreamsWsdl, reader);
  905.                 }
  906.             }
  907.             ReadNextXmlElement();
  908.             return;
  909.         }
  910.        
  911.         // Controls the processing of the imported xsd schema.
  912.         internal void ParseImportedSchemaController()
  913.         {
  914.             Util.Log("WsdlParser.ParseImportedSchemaController");
  915.             XmlNameTable primedNametable = CreatePrimedNametable();
  916.             ReaderStream input = _readerStreamsXsd;
  917.             XmlTextReader _XMLReaderWsdl = _XMLReader;
  918.             ReaderStream _parsingInputWsdl = _parsingInput;
  919.             do {
  920.                 // Initialize the parser
  921.                 _XMLReader = new XmlTextReader(input.InputStream, _primedNametable);
  922.                 _XMLReader.WhitespaceHandling = WhitespaceHandling.None;
  923.                 _XMLReader.XmlResolver = null;
  924.                 _parsingInput = input;
  925.                 ParseImportedSchema(input);
  926.                 input = ReaderStream.GetNextReaderStream(input);
  927.             }
  928.             while (input != null);
  929.             _readerStreamsXsd = null;
  930.             _XMLReader = _XMLReaderWsdl;
  931.             _parsingInput = _parsingInputWsdl;
  932.             return;
  933.         }
  934.        
  935.         // Process the xsd schema imported from an xsd import statement
  936.         private void ParseImportedSchema(ReaderStream input)
  937.         {
  938.             Util.Log("WsdlParser.ParseImportedSchema " + input.Location);
  939.             try {
  940.                 string elementName = _XMLReader.LocalName;
  941.                 _currentSchemaReaderStack.Push(input);
  942.                 // need this to get the base url for relative import elements.
  943.                 ReadNextXmlElement();
  944.                 ParseSchema();
  945.                 _currentSchemaReaderStack.Pop();
  946.                 // need this to get the base url for relative import elements.
  947.             }
  948.             finally {
  949.                 WriterStream.Flush(_writerStreams);
  950.             }
  951.         }
  952.        
  953.         private void ParseWsdlMessage()
  954.         {
  955.             Util.Log("WsdlParser.ParseWsdlMessage");
  956.             WsdlMessage message = new WsdlMessage();
  957.             message.name = LookupAttribute(s_nameString, null, true);
  958.             message.nameNs = _parsingInput.TargetNS;
  959.             int curDepth = _XMLReader.Depth;
  960.             ReadNextXmlElement();
  961.             while (_XMLReader.Depth > curDepth) {
  962.                 string elementName = _XMLReader.LocalName;
  963.                
  964.                 if (MatchingStrings(elementName, s_partString)) {
  965.                     WsdlMessagePart part = new WsdlMessagePart();
  966.                     part.name = LookupAttribute(s_nameString, null, true);
  967.                     part.nameNs = _parsingInput.TargetNS;
  968.                     //AddToNamespace(part.nameNs);//temp
  969.                     part.element = LookupAttribute(s_elementString, null, false);
  970.                     part.typeName = LookupAttribute(s_typeString, null, false);
  971.                     if (part.element != null) {
  972.                         part.elementNs = ParseQName(ref part.element);
  973.                     }
  974.                     if (part.typeName != null) {
  975.                         part.typeNameNs = ParseQName(ref part.typeName);
  976.                     }
  977.                    
  978.                     message.parts.Add(part);
  979.                     ReadNextXmlElement();
  980.                     continue;
  981.                 }
  982.                
  983.                 // Ignore others elements such as annotations
  984.                 SkipXmlElement();
  985.             }
  986.             wsdlMessages[message.name] = message;
  987.         }
  988.        
  989.         private void ParseWsdlPortType()
  990.         {
  991.             Util.Log("WsdlParser.ParseWsdlPortType");
  992.             WsdlPortType portType = new WsdlPortType();
  993.             portType.name = LookupAttribute(s_nameString, null, true);
  994.             //portType.nameNs = ParseQName(ref portType.name);
  995.             int curDepth = _XMLReader.Depth;
  996.             ReadNextXmlElement();
  997.             while (_XMLReader.Depth > curDepth) {
  998.                 string elementName = _XMLReader.LocalName;
  999.                
  1000.                 if (MatchingStrings(elementName, s_operationString)) {
  1001.                     WsdlPortTypeOperation portTypeOperation = new WsdlPortTypeOperation();
  1002.                     portTypeOperation.name = LookupAttribute(s_nameString, null, true);
  1003.                     portTypeOperation.nameNs = ParseQName(ref portTypeOperation.nameNs);
  1004.                     portTypeOperation.parameterOrder = LookupAttribute(s_parameterOrderString, null, false);
  1005.                     ParseWsdlPortTypeOperationContent(portType, portTypeOperation);
  1006.                     portType.operations.Add(portTypeOperation);
  1007.                     continue;
  1008.                 }
  1009.                
  1010.                 // Ignore others elements such as annotations
  1011.                 SkipXmlElement();
  1012.             }
  1013.             wsdlPortTypes[portType.name] = portType;
  1014.         }
  1015.        
  1016.        
  1017.         private void ParseWsdlPortTypeOperationContent(WsdlPortType portType, WsdlPortTypeOperation portTypeOperation)
  1018.         {
  1019.             Util.Log("WsdlParser.ParseWsdlPortTypeOperationContent type " + portType.name + " operationName " + portTypeOperation.name);
  1020.             int curDepth = _XMLReader.Depth;
  1021.            
  1022.             ReadNextXmlElement();
  1023.             while (_XMLReader.Depth > curDepth) {
  1024.                 string elementName = _XMLReader.LocalName;
  1025.                
  1026.                 if (MatchingStrings(elementName, s_inputString)) {
  1027.                     WsdlPortTypeOperationContent portContent = new WsdlPortTypeOperationContent();
  1028.                     portContent.element = Atomize("input");
  1029.                     portContent.name = LookupAttribute(s_nameString, null, false);
  1030.                    
  1031.                     if (MatchingStrings(portContent.name, s_emptyString)) {
  1032.                         portContent.name = Atomize(portTypeOperation.name + "Request");
  1033.                         if (portType.sections.ContainsKey(portContent.name))
  1034.                             throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_DuplicatePortTypesOperationName"), portTypeOperation.name));
  1035.                        
  1036.                         portType.sections[portContent.name] = portTypeOperation;
  1037.                         //for request response
  1038.                         portType.sections[portTypeOperation.name] = portTypeOperation;
  1039.                         // for one way don't know yet if one way or response
  1040.                     }
  1041.                     else {
  1042.                         if (portType.sections.ContainsKey(portContent.name))
  1043.                             throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_DuplicatePortSectionName"), portContent.name));
  1044.                        
  1045.                        
  1046.                         portType.sections[portContent.name] = portTypeOperation;
  1047.                     }
  1048.                    
  1049.                     portContent.message = LookupAttribute(s_messageString, null, true);
  1050.                     portContent.messageNs = ParseQName(ref portContent.message);
  1051.                     portTypeOperation.contents.Add(portContent);
  1052.                     ReadNextXmlElement();
  1053.                     continue;
  1054.                 }
  1055.                 else if (MatchingStrings(elementName, s_outputString)) {
  1056.                     WsdlPortTypeOperationContent portContent = new WsdlPortTypeOperationContent();
  1057.                     portContent.element = Atomize("output");
  1058.                     portContent.name = LookupAttribute(s_nameString, null, false);
  1059.                     portContent.nameNs = ParseQName(ref portContent.name);
  1060.                     if (MatchingStrings(portContent.name, s_emptyString))
  1061.                         portContent.name = Atomize(portTypeOperation.name + "Response");
  1062.                     if (!portType.sections.ContainsKey(portContent.name))
  1063.                         portType.sections[portContent.name] = portTypeOperation;
  1064.                     portContent.message = LookupAttribute(s_messageString, null, true);
  1065.                     portContent.messageNs = ParseQName(ref portContent.message);
  1066.                     portTypeOperation.contents.Add(portContent);
  1067.                     ReadNextXmlElement();
  1068.                     continue;
  1069.                 }
  1070.                
  1071.                 // Ignore others elements such as annotations
  1072.                 SkipXmlElement();
  1073.             }
  1074.         }
  1075.        
  1076.        
  1077.         private void ParseWsdlBinding(URTNamespace inparsingNamespace)
  1078.         {
  1079.             Util.Log("WsdlParser.ParseWsdlBinding");
  1080.             WsdlBinding binding = new WsdlBinding();
  1081.             binding.name = LookupAttribute(s_nameString, null, true);
  1082.             //binding.nameNs = ParseQName(ref binding.name);
  1083.             binding.type = LookupAttribute(s_typeString, null, true);
  1084.             binding.typeNs = ParseQName(ref binding.type);
  1085.             URTNamespace parsingNamespace = LookupNamespace(binding.typeNs);
  1086.             if (parsingNamespace == null) {
  1087.                 parsingNamespace = new URTNamespace(binding.typeNs, this);
  1088.             }
  1089.             binding.parsingNamespace = parsingNamespace;
  1090.             bool bSoapBinding = false;
  1091.             bool bRpcBinding = false;
  1092.             bool bSoapEncoded = false;
  1093.             bool bSoapSuds = false;
  1094.             int curDepth = _XMLReader.Depth;
  1095.             ReadNextXmlElement();
  1096.             while (_XMLReader.Depth > curDepth) {
  1097.                 string elementName = _XMLReader.LocalName;
  1098.                 if (MatchingNamespace(s_wsdlSoapNamespaceString) && MatchingStrings(elementName, s_bindingString)) {
  1099.                     bSoapBinding = true;
  1100.                     WsdlBindingSoapBinding sb = new WsdlBindingSoapBinding();
  1101.                     sb.style = LookupAttribute(s_styleString, null, true);
  1102.                     if (sb.style == "rpc")
  1103.                         bRpcBinding = true;
  1104.                    
  1105.                     /*
  1106.                     if (sb.style == "document")
  1107.                     {
  1108.                         throw new SUDSParserException(
  1109.                             String.Format(CoreChannel.GetResourceString("Remoting_Suds_SoapStyleNotSupported"),
  1110.                                           sb.style));
  1111.                     }
  1112.                     */                   
  1113.                    
  1114. sb.transport = LookupAttribute(s_transportString, null, true);
  1115.                     binding.soapBinding = sb;
  1116.                     ReadNextXmlElement();
  1117.                     continue;
  1118.                 }
  1119.                 else if (MatchingNamespace(s_wsdlSudsNamespaceString)) {
  1120.                     bSoapSuds = true;
  1121.                     if (MatchingStrings(elementName, s_classString) || MatchingStrings(elementName, s_structString)) {
  1122.                         WsdlBindingSuds suds = new WsdlBindingSuds();
  1123.                         suds.elementName = elementName;
  1124.                         suds.typeName = LookupAttribute(s_typeString, null, true);
  1125.                         suds.ns = ParseQName(ref suds.typeName);
  1126.                         suds.extendsTypeName = LookupAttribute(s_extendsString, null, false);
  1127.                         string use = LookupAttribute(s_rootTypeString, null, false);
  1128.                         suds.sudsUse = ProcessSudsUse(use, elementName);
  1129.                         if (!MatchingStrings(suds.extendsTypeName, s_emptyString))
  1130.                             suds.extendsNs = ParseQName(ref suds.extendsTypeName);
  1131.                         ParseWsdlBindingSuds(suds);
  1132.                         binding.suds.Add(suds);
  1133.                         continue;
  1134.                     }
  1135.                     else if (MatchingStrings(elementName, s_interfaceString)) {
  1136.                         WsdlBindingSuds suds = new WsdlBindingSuds();
  1137.                         suds.elementName = elementName;
  1138.                         //Atomize("interface");
  1139.                         suds.typeName = LookupAttribute(s_typeString, null, true);
  1140.                         suds.ns = ParseQName(ref suds.typeName);
  1141.                         string use = LookupAttribute(s_rootTypeString, null, false);
  1142.                         suds.sudsUse = ProcessSudsUse(use, elementName);
  1143.                         ParseWsdlBindingSuds(suds);
  1144.                         binding.suds.Add(suds);
  1145.                         continue;
  1146.                     }
  1147.                 }
  1148.                 else if (MatchingNamespace(s_wsdlNamespaceString) && MatchingStrings(elementName, s_operationString)) {
  1149.                     WsdlBindingOperation op = new WsdlBindingOperation();
  1150.                     op.name = LookupAttribute(s_nameString, null, true);
  1151.                     op.nameNs = _parsingInput.TargetNS;
  1152.                     ParseWsdlBindingOperation(op, ref bRpcBinding, ref bSoapEncoded);
  1153.                     binding.operations.Add(op);
  1154.                     continue;
  1155.                 }
  1156.                
  1157.                 // Ignore others elements such as annotations
  1158.                 SkipXmlElement();
  1159.             }
  1160.             if (bSoapBinding && bRpcBinding && bSoapEncoded || bSoapSuds)
  1161.                 wsdlBindings.Add(binding);
  1162.         }
  1163.        
  1164.         private void ParseWsdlBindingSuds(WsdlBindingSuds suds)
  1165.         {
  1166.             Util.Log("WsdlParser.ParseWsdlBindingSuds");
  1167.             int curDepth = _XMLReader.Depth;
  1168.             ReadNextXmlElement();
  1169.             while (_XMLReader.Depth > curDepth) {
  1170.                 string elementName = _XMLReader.LocalName;
  1171.                
  1172.                 if (MatchingStrings(elementName, s_implementsString) || MatchingStrings(elementName, s_extendsString)) {
  1173.                     WsdlBindingSudsImplements impl = new WsdlBindingSudsImplements();
  1174.                     impl.typeName = LookupAttribute(s_typeString, null, true);
  1175.                     impl.ns = ParseQName(ref impl.typeName);
  1176.                     suds.implements.Add(impl);
  1177.                     ReadNextXmlElement();
  1178.                     continue;
  1179.                 }
  1180.                 else if (MatchingStrings(elementName, s_nestedTypeString)) {
  1181.                     WsdlBindingSudsNestedType nestedType = new WsdlBindingSudsNestedType();
  1182.                     nestedType.name = LookupAttribute(s_nameString, null, true);
  1183.                     nestedType.typeName = LookupAttribute(s_typeString, null, true);
  1184.                     nestedType.ns = ParseQName(ref nestedType.typeName);
  1185.                     suds.nestedTypes.Add(nestedType);
  1186.                     ReadNextXmlElement();
  1187.                     continue;
  1188.                 }
  1189.                
  1190.                
  1191.                 // Ignore others elements such as annotations
  1192.                 SkipXmlElement();
  1193.             }
  1194.         }
  1195.        
  1196.         private SudsUse ProcessSudsUse(string use, string elementName)
  1197.         {
  1198.             Util.Log("WsdlParser.ProcessSudsUse use enter " + use + " elementName " + elementName);
  1199.             SudsUse sudsUse = SudsUse.Class;
  1200.            
  1201.             if (use == null || use.Length == 0)
  1202.                 use = elementName;
  1203.            
  1204.             if (MatchingStrings(use, s_interfaceString))
  1205.                 sudsUse = SudsUse.Interface;
  1206.             else if (MatchingStrings(use, s_classString))
  1207.                 sudsUse = SudsUse.Class;
  1208.             else if (MatchingStrings(use, s_structString))
  1209.                 sudsUse = SudsUse.Struct;
  1210.             else if (MatchingStrings(use, s_ISerializableString))
  1211.                 sudsUse = SudsUse.ISerializable;
  1212.             else if (MatchingStrings(use, s_marshalByRefString))
  1213.                 sudsUse = SudsUse.MarshalByRef;
  1214.             else if (MatchingStrings(use, s_delegateString))
  1215.                 sudsUse = SudsUse.Delegate;
  1216.             else if (MatchingStrings(use, s_servicedComponentString))
  1217.                 sudsUse = SudsUse.ServicedComponent;
  1218.            
  1219.             Util.Log("WsdlParser.ProcessSudsUse use exit " + ((Enum)sudsUse).ToString());
  1220.             return sudsUse;
  1221.         }
  1222.        
  1223.         private void ParseWsdlBindingOperation(WsdlBindingOperation op, ref bool bRpcBinding, ref bool bSoapEncoded)
  1224.         {
  1225.             Util.Log("WsdlParser.ParseWsdlBindingOperation");
  1226.             int curDepth = _XMLReader.Depth;
  1227.             bool binput = false;
  1228.             bool boutput = false;
  1229.             WsdlBindingOperationSection opSec = null;
  1230.            
  1231.             ReadNextXmlElement();
  1232.            
  1233.             while (_XMLReader.Depth > curDepth) {
  1234.                 string elementName = _XMLReader.LocalName;
  1235.                
  1236.                 if (MatchingNamespace(s_wsdlSudsNamespaceString) && MatchingStrings(elementName, s_methodString)) {
  1237.                     op.methodAttributes = LookupAttribute(s_attributesString, null, true);
  1238.                     ReadNextXmlElement();
  1239.                     continue;
  1240.                 }
  1241.                 else if (MatchingNamespace(s_wsdlSoapNamespaceString) && MatchingStrings(elementName, s_operationString)) {
  1242.                     WsdlBindingSoapOperation soapOp = new WsdlBindingSoapOperation();
  1243.                     soapOp.soapAction = LookupAttribute(s_soapActionString, null, false);
  1244.                     soapOp.style = LookupAttribute(s_styleString, null, false);
  1245.                     if (soapOp.style == "rpc")
  1246.                         bRpcBinding = true;
  1247.                     {
  1248.                     }
  1249.                     op.soapOperation = soapOp;
  1250.                     ReadNextXmlElement();
  1251.                     continue;
  1252.                 }
  1253.                 else if (MatchingNamespace(s_wsdlNamespaceString)) {
  1254.                     if (MatchingStrings(elementName, s_inputString)) {
  1255.                         binput = true;
  1256.                         opSec = ParseWsdlBindingOperationSection(op, elementName, ref bSoapEncoded);
  1257.                         continue;
  1258.                     }
  1259.                     else if (MatchingStrings(elementName, s_outputString)) {
  1260.                         boutput = true;
  1261.                         ParseWsdlBindingOperationSection(op, elementName, ref bSoapEncoded);
  1262.                         continue;
  1263.                     }
  1264.                     else if (MatchingStrings(elementName, s_faultString)) {
  1265.                         ParseWsdlBindingOperationSection(op, elementName, ref bSoapEncoded);
  1266.                         continue;
  1267.                     }
  1268.                 }
  1269.                
  1270.                 // Ignore others elements such as annotations
  1271.                 SkipXmlElement();
  1272.             }
  1273.            
  1274.             // if no output section then the default name is just the op name.
  1275.             if (opSec != null && binput && !boutput)
  1276.                 opSec.name = op.name;
  1277.            
  1278.            
  1279.         }
  1280.        
  1281.         private WsdlBindingOperationSection ParseWsdlBindingOperationSection(WsdlBindingOperation op, string inputElementName, ref bool bSoapEncoded)
  1282.         {
  1283.             Util.Log("WsdlParser.ParseWsdlBindingOperationSections");
  1284.             bool breturn = false;
  1285.             WsdlBindingOperationSection opSec = new WsdlBindingOperationSection();
  1286.             op.sections.Add(opSec);
  1287.             opSec.name = LookupAttribute(s_nameString, null, false);
  1288.             if (MatchingStrings(opSec.name, s_emptyString)) {
  1289.                 if (MatchingStrings(inputElementName, s_inputString)) {
  1290.                     breturn = true;
  1291.                     opSec.name = Atomize(op.name + "Request");
  1292.                 }
  1293.                 else if (MatchingStrings(inputElementName, s_outputString))
  1294.                     opSec.name = Atomize(op.name + "Response");
  1295.             }
  1296.             opSec.elementName = inputElementName;
  1297.             int curDepth = _XMLReader.Depth;
  1298.             ReadNextXmlElement();
  1299.             while (_XMLReader.Depth > curDepth) {
  1300.                 string elementName = _XMLReader.LocalName;
  1301.                 if (MatchingNamespace(s_wsdlSoapNamespaceString)) {
  1302.                     if (MatchingStrings(elementName, s_bodyString)) {
  1303.                         WsdlBindingSoapBody soapBody = new WsdlBindingSoapBody();
  1304.                         opSec.extensions.Add(soapBody);
  1305.                         soapBody.parts = LookupAttribute(s_partsString, null, false);
  1306.                         soapBody.use = LookupAttribute(s_useString, null, true);
  1307.                         if (soapBody.use == "encoded")
  1308.                             bSoapEncoded = true;
  1309.                         soapBody.encodingStyle = LookupAttribute(s_encodingStyleString, null, false);
  1310.                         soapBody.namespaceUri = LookupAttribute(s_namespaceString, null, false);
  1311.                         ReadNextXmlElement();
  1312.                         continue;
  1313.                     }
  1314.                     else if (MatchingStrings(elementName, s_headerString)) {
  1315.                         WsdlBindingSoapHeader soapHeader = new WsdlBindingSoapHeader();
  1316.                         opSec.extensions.Add(soapHeader);
  1317.                         soapHeader.message = LookupAttribute(s_messageString, null, true);
  1318.                         soapHeader.messageNs = ParseQName(ref soapHeader.message);
  1319.                         soapHeader.part = LookupAttribute(s_partString, null, true);
  1320.                         soapHeader.use = LookupAttribute(s_useString, null, true);
  1321.                         soapHeader.encodingStyle = LookupAttribute(s_encodingStyleString, null, false);
  1322.                         soapHeader.namespaceUri = LookupAttribute(s_namespaceString, null, false);
  1323.                         ReadNextXmlElement();
  1324.                         continue;
  1325.                     }
  1326.                     else if (MatchingStrings(elementName, s_faultString)) {
  1327.                         WsdlBindingSoapFault soapFault = new WsdlBindingSoapFault();
  1328.                         opSec.extensions.Add(soapFault);
  1329.                         soapFault.name = LookupAttribute(s_nameString, null, true);
  1330.                         soapFault.use = LookupAttribute(s_useString, null, true);
  1331.                         soapFault.encodingStyle = LookupAttribute(s_encodingStyleString, null, false);
  1332.                         soapFault.namespaceUri = LookupAttribute(s_namespaceString, null, false);
  1333.                         ReadNextXmlElement();
  1334.                         continue;
  1335.                     }
  1336.                    
  1337.                 }
  1338.                 // Ignore others elements such as annotations
  1339.                 // headerFault currently ignored
  1340.                 SkipXmlElement();
  1341.             }
  1342.            
  1343.             // returning opSec only if a fixup might be necessary, this is the case of an input section with an empty input name
  1344.             // it will be fixed up later if there is no output section
  1345.             if (breturn)
  1346.                 return opSec;
  1347.             else
  1348.                 return null;
  1349.         }
  1350.        
  1351.         private void ParseWsdlService()
  1352.         {
  1353.             Util.Log("WsdlParser.ParseWsdlService");
  1354.             WsdlService service = new WsdlService();
  1355.             service.name = LookupAttribute(s_nameString, null, true);
  1356.             //service.nameNs = ParseQName(ref service.name);
  1357.             int curDepth = _XMLReader.Depth;
  1358.             ReadNextXmlElement();
  1359.             while (_XMLReader.Depth > curDepth) {
  1360.                 string elementName = _XMLReader.LocalName;
  1361.                
  1362.                 if (MatchingNamespace(s_wsdlNamespaceString) && MatchingStrings(elementName, s_portString)) {
  1363.                     WsdlServicePort port = new WsdlServicePort();
  1364.                     port.name = LookupAttribute(s_nameString, null, true);
  1365.                     port.nameNs = ParseQName(ref port.nameNs);
  1366.                     port.binding = LookupAttribute(s_bindingString, null, true);
  1367.                     port.bindingNs = ParseQName(ref port.binding);
  1368.                     ParseWsdlServicePort(port);
  1369.                     service.ports[port.binding] = port;
  1370.                     continue;
  1371.                 }
  1372.                
  1373.                 // Ignore others elements such as annotations
  1374.                 SkipXmlElement();
  1375.             }
  1376.             wsdlServices.Add(service);
  1377.         }
  1378.        
  1379.         private void ParseWsdlServicePort(WsdlServicePort port)
  1380.         {
  1381.             Util.Log("WsdlParser.ParseWsdlServicePort");
  1382.             int curDepth = _XMLReader.Depth;
  1383.             ReadNextXmlElement();
  1384.             while (_XMLReader.Depth > curDepth) {
  1385.                 string elementName = _XMLReader.LocalName;
  1386.                 if (MatchingNamespace(s_wsdlSoapNamespaceString) && MatchingStrings(elementName, s_addressString)) {
  1387.                     if (port.locations == null)
  1388.                         port.locations = new ArrayList(10);
  1389.                     port.locations.Add(LookupAttribute(s_locationString, null, true));
  1390.                     ReadNextXmlElement();
  1391.                     continue;
  1392.                 }
  1393.                
  1394.                 // Ignore others elements such as annotations
  1395.                 SkipXmlElement();
  1396.             }
  1397.         }
  1398.        
  1399.         private void ResolveWsdl()
  1400.         {
  1401.             Util.Log("WsdlParser.ResolveWsdl ");
  1402.            
  1403.             if (wsdlBindings.Count == 0)
  1404.                 throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_RpcBindingsMissing")));
  1405.            
  1406.             foreach (WsdlBinding binding in wsdlBindings) {
  1407.                 // Only creating classes for soap
  1408.                 if (binding.soapBinding != null) {
  1409.                     if (binding.suds != null && binding.suds.Count > 0) {
  1410.                         bool bFirstSuds = true;
  1411.                         foreach (WsdlBindingSuds suds in binding.suds) {
  1412.                             if (MatchingStrings(suds.elementName, s_classString) || MatchingStrings(suds.elementName, s_structString)) {
  1413.                                 ResolveWsdlClass(binding, suds, bFirstSuds);
  1414.                                 bFirstSuds = false;
  1415.                             }
  1416.                             else if (MatchingStrings(suds.elementName, s_interfaceString))
  1417.                                 ResolveWsdlInterface(binding, suds);
  1418.                             else {
  1419.                                 throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveElementInNS"), suds.elementName, s_wsdlSudsNamespaceString));
  1420.                             }
  1421.                         }
  1422.                     }
  1423.                     else
  1424.                         ResolveWsdlClass(binding, null, true);
  1425.                     // No suds, create a default class
  1426.                 }
  1427.             }
  1428.         }
  1429.        
  1430.         private void ResolveWsdlClass(WsdlBinding binding, WsdlBindingSuds suds, bool bFirstSuds)
  1431.         {
  1432.             // bFirstSuds is true then the suds class is the class for the binding.
  1433.             // The other suds are additional class without bindings in the same namespace.
  1434.             Util.Log("WsdlParser.ResolveWsdlClass suds " + suds);
  1435.             URTComplexType parsingComplexType;
  1436.             //URTNamespace parsingNamespace = binding.parsingNamespace;
  1437.             URTNamespace parsingNamespace;
  1438.             //URTNamespace parsingNamespace = binding.typeNs;
  1439.            
  1440.             if (suds != null) {
  1441.                 Util.Log("WsdlParser.ResolveWsdlClass suds not null " + suds.elementName + " " + suds.typeName);
  1442.                 // Suds
  1443.                 parsingNamespace = AddNewNamespace(suds.ns);
  1444.                 parsingComplexType = parsingNamespace.LookupComplexType(suds.typeName);
  1445.                 if (parsingComplexType == null) {
  1446.                     parsingComplexType = new URTComplexType(suds.typeName, parsingNamespace.Name, parsingNamespace.Namespace, parsingNamespace.EncodedNS, _blockDefault, false, false, this, parsingNamespace);
  1447.                     parsingNamespace.AddComplexType(parsingComplexType);
  1448.                 }
  1449.                
  1450.                 if (MatchingStrings(suds.elementName, s_structString))
  1451.                     parsingComplexType.IsValueType = true;
  1452.                
  1453.                 parsingComplexType.SudsUse = suds.sudsUse;
  1454.                
  1455.                 if (suds.sudsUse == SudsUse.MarshalByRef || suds.sudsUse == SudsUse.ServicedComponent) {
  1456.                     Util.Log("WsdlParser.ResolveWsdlClass MarshalByRef IsSudsType true 1 " + suds.elementName + " " + suds.typeName);
  1457.                     parsingComplexType.IsSUDSType = true;
  1458.                    
  1459.                     if (_bWrappedProxy)
  1460.                         parsingComplexType.SUDSType = SUDSType.ClientProxy;
  1461.                     else
  1462.                         parsingComplexType.SUDSType = SUDSType.MarshalByRef;
  1463.                    
  1464.                    
  1465.                     if ((suds.extendsTypeName != null) && (suds.extendsTypeName.Length > 0)) {
  1466.                         URTNamespace extendsNamespace = AddNewNamespace(suds.extendsNs);
  1467.                         /*
  1468.                         if (extendsNamespace == null)
  1469.                             extendsNamespace = new URTNamespace(suds.extendsTypeName, this);
  1470.                             */                       
  1471.                        
  1472. URTComplexType extendsComplexType = extendsNamespace.LookupComplexType(suds.extendsTypeName);
  1473.                         if (extendsComplexType == null) {
  1474.                             extendsComplexType = new URTComplexType(suds.extendsTypeName, extendsNamespace.Name, extendsNamespace.Namespace, extendsNamespace.EncodedNS, _blockDefault, true, false, this, extendsNamespace);
  1475.                             extendsNamespace.AddComplexType(extendsComplexType);
  1476.                         }
  1477.                         else {
  1478.                             Util.Log("WsdlParser.ResolveWsdlClass IsSudsType true 2 " + suds.elementName + " " + suds.typeName);
  1479.                             extendsComplexType.IsSUDSType = true;
  1480.                         }
  1481.                        
  1482.                         if (_bWrappedProxy)
  1483.                             extendsComplexType.SUDSType = SUDSType.ClientProxy;
  1484.                         else
  1485.                             extendsComplexType.SUDSType = SUDSType.MarshalByRef;
  1486.                        
  1487.                         extendsComplexType.SudsUse = suds.sudsUse;
  1488.                        
  1489.                         // Only top of inheritance hierarchy is marked
  1490.                         //parsingComplexType.SUDSType = SUDSType.None;
  1491.                     }
  1492.                 }
  1493.                
  1494.                 foreach (WsdlBindingSudsNestedType nestedType in suds.nestedTypes) {
  1495.                     ResolveWsdlNestedType(binding, suds, nestedType);
  1496.                 }
  1497.             }
  1498.             else {
  1499.                 // No suds
  1500.                 Util.Log("WsdlParser.ResolveWsdlClass no suds ");
  1501.                 parsingNamespace = AddNewNamespace(binding.typeNs);
  1502.                 string name = binding.name;
  1503.                 int index = binding.name.IndexOf("Binding");
  1504.                 if (index > 0) {
  1505.                     //name = Atomize(binding.name.Substring(0,index));
  1506.                     name = binding.name.Substring(0, index);
  1507.                 }
  1508.                
  1509.                 parsingComplexType = parsingNamespace.LookupComplexTypeEqual(name);
  1510.                 if (parsingComplexType == null) {
  1511.                     parsingComplexType = new URTComplexType(name, parsingNamespace.Name, parsingNamespace.Namespace, parsingNamespace.EncodedNS, _blockDefault, true, false, this, parsingNamespace);
  1512.                     parsingNamespace.AddComplexType(parsingComplexType);
  1513.                 }
  1514.                 else {
  1515.                     Util.Log("WsdlParser.ResolveWsdlClass IsSudsType true 3 " + name);
  1516.                     parsingComplexType.IsSUDSType = true;
  1517.                 }
  1518.                 if (_bWrappedProxy)
  1519.                     parsingComplexType.SUDSType = SUDSType.ClientProxy;
  1520.                 else
  1521.                     parsingComplexType.SUDSType = SUDSType.MarshalByRef;
  1522.                
  1523.                 parsingComplexType.SudsUse = SudsUse.MarshalByRef;
  1524.             }
  1525.            
  1526.             // Resolve address
  1527.             parsingComplexType.ConnectURLs = ResolveWsdlAddress(binding);
  1528.            
  1529.             // Resolve extends and implements
  1530.             if (suds != null) {
  1531.                 if (!MatchingStrings(suds.extendsTypeName, s_emptyString)) {
  1532.                     parsingComplexType.Extends(suds.extendsTypeName, suds.extendsNs);
  1533.                 }
  1534.                
  1535.                 foreach (WsdlBindingSudsImplements impl in suds.implements)
  1536.                     parsingComplexType.Implements(impl.typeName, impl.ns, this);
  1537.             }
  1538.            
  1539.            
  1540.            
  1541.            
  1542.             if (bFirstSuds && (parsingComplexType.SudsUse == SudsUse.MarshalByRef || parsingComplexType.SudsUse == SudsUse.ServicedComponent || parsingComplexType.SudsUse == SudsUse.Delegate || parsingComplexType.SudsUse == SudsUse.Interface)) {
  1543.                 // Resolve methods
  1544.                
  1545.                 ArrayList methodInfos = ResolveWsdlMethodInfo(binding);
  1546.                
  1547.                 foreach (WsdlMethodInfo methodInfo in methodInfos) {
  1548.                     if ((methodInfo.inputMethodName != null) && (methodInfo.outputMethodName != null)) {
  1549.                         RRMethod parsingRRMethod = new RRMethod(methodInfo, parsingComplexType);
  1550.                         parsingRRMethod.AddRequest(methodInfo.methodName, methodInfo.methodNameNs);
  1551.                         parsingRRMethod.AddResponse(methodInfo.methodName, methodInfo.methodNameNs);
  1552.                         parsingComplexType.AddMethod(parsingRRMethod);
  1553.                     }
  1554.                     else if (methodInfo.inputMethodName != null) {
  1555.                         OnewayMethod parsingOWMethod = new OnewayMethod(methodInfo, parsingComplexType);
  1556.                         parsingComplexType.AddMethod(parsingOWMethod);
  1557.                         parsingOWMethod.AddMessage(methodInfo.methodName, methodInfo.methodNameNs);
  1558.                     }
  1559.                     else {
  1560.                         throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_WsdlInvalidMessage"), methodInfo.methodName));
  1561.                     }
  1562.                 }
  1563.             }
  1564.         }
  1565.        
  1566.         private void ResolveWsdlInterface(WsdlBinding binding, WsdlBindingSuds suds)
  1567.         {
  1568.             Util.Log("WsdlParser.ResolveWsdlInterface " + binding.name + " ns " + binding.parsingNamespace.Namespace + " suds " + suds.typeName);
  1569.            
  1570.             URTNamespace parsingNamespace = binding.parsingNamespace;
  1571.            
  1572.             URTNamespace sudsNamespace = AddNewNamespace(suds.ns);
  1573.             /*
  1574.             if (sudsNamespace == null)
  1575.             {
  1576.                 sudsNamespace = new URTNamespace(suds.ns, this);
  1577.             }
  1578.             */           
  1579.            
  1580. URTInterface parsingInterface = sudsNamespace.LookupInterface(suds.typeName);
  1581.             if (parsingInterface == null) {
  1582.                 parsingInterface = new URTInterface(suds.typeName, sudsNamespace.Name, sudsNamespace.Namespace, sudsNamespace.EncodedNS, this);
  1583.                 sudsNamespace.AddInterface(parsingInterface);
  1584.             }
  1585.            
  1586.             if (suds.extendsTypeName != null) {
  1587.                 parsingInterface.Extends(suds.extendsTypeName, suds.extendsNs, this);
  1588.             }
  1589.             foreach (WsdlBindingSudsImplements impl in suds.implements) {
  1590.                 parsingInterface.Extends(impl.typeName, impl.ns, this);
  1591.             }
  1592.            
  1593.             ArrayList methodInfos = ResolveWsdlMethodInfo(binding);
  1594.            
  1595.             foreach (WsdlMethodInfo methodInfo in methodInfos) {
  1596.                 if ((methodInfo.inputMethodName != null) && (methodInfo.outputMethodName != null)) {
  1597.                     RRMethod parsingRRMethod = new RRMethod(methodInfo, null);
  1598.                     parsingRRMethod.AddRequest(methodInfo.methodName, methodInfo.methodNameNs);
  1599.                     parsingRRMethod.AddResponse(methodInfo.methodName, methodInfo.methodNameNs);
  1600.                     parsingInterface.AddMethod(parsingRRMethod);
  1601.                 }
  1602.                 else if (methodInfo.inputMethodName != null) {
  1603.                     OnewayMethod parsingOWMethod = new OnewayMethod(methodInfo.methodName, methodInfo.soapAction, null);
  1604.                     parsingOWMethod.AddMessage(methodInfo.methodName, methodInfo.methodNameNs);
  1605.                     parsingInterface.AddMethod(parsingOWMethod);
  1606.                 }
  1607.                 else {
  1608.                     throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_WsdlInvalidMessage"), methodInfo.methodName));
  1609.                    
  1610.                 }
  1611.             }
  1612.         }
  1613.        
  1614.         private void ResolveWsdlNestedType(WsdlBinding binding, WsdlBindingSuds suds, WsdlBindingSudsNestedType nested)
  1615.         {
  1616.             Util.Log("WsdlParser.ResolveWsdlNestedType " + binding.name + " ns " + binding.parsingNamespace.Namespace + " suds " + suds.typeName + " nestedName " + nested.name + " nestedTypeName " + nested.typeName);
  1617.             string className = suds.typeName;
  1618.             string ns = nested.ns;
  1619.             string nestedName = nested.name;
  1620.             string nestedTypeName = nested.typeName;
  1621.             if (suds.ns != ns) {
  1622.                 throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveNestedTypeNS"), suds.typeName, suds.ns));
  1623.             }
  1624.            
  1625.             URTNamespace sudsNamespace = AddNewNamespace(suds.ns);
  1626.            
  1627.             URTComplexType outerType = sudsNamespace.LookupComplexType(suds.typeName);
  1628.             if (outerType == null) {
  1629.                 throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveNestedType"), suds.typeName, suds.ns));
  1630.             }
  1631.            
  1632.             BaseType innerType = sudsNamespace.LookupType(nested.typeName);
  1633.             if (innerType == null) {
  1634.                 // Can be URTSimpleType for Enum
  1635.                 Util.Log("WsdlParser.ResolveWsdlNestedType cann't find inner type " + nested.typeName + " className " + className + " ns " + ns);
  1636.                
  1637.                 innerType = sudsNamespace.LookupComplexType(nested.typeName);
  1638.                 if (innerType == null) {
  1639.                     innerType = new URTComplexType(nested.typeName, sudsNamespace.Name, sudsNamespace.Namespace, sudsNamespace.EncodedNS, _blockDefault, false, false, this, sudsNamespace);
  1640.                     sudsNamespace.AddComplexType((URTComplexType)innerType);
  1641.                 }
  1642.             }
  1643.            
  1644.            
  1645.             innerType.bNestedType = true;
  1646.             innerType.NestedTypeName = nested.name;
  1647.             innerType.FullNestedTypeName = nested.typeName;
  1648.             innerType.OuterTypeName = suds.typeName;
  1649.            
  1650.             outerType.AddNestedType(innerType);
  1651.         }
  1652.        
  1653.         private ArrayList ResolveWsdlAddress(WsdlBinding binding)
  1654.         {
  1655.             Util.Log("WsdlParser.ResolveWsdlAddress " + binding.name);
  1656.             ArrayList serviceEndpoints = null;
  1657.             if (_bWrappedProxy) {
  1658.                 foreach (WsdlService service in wsdlServices) {
  1659.                     WsdlServicePort port = (WsdlServicePort)service.ports[binding.name];
  1660.                     if (port != null) {
  1661.                         serviceEndpoints = port.locations;
  1662.                         break;
  1663.                     }
  1664.                     if (serviceEndpoints != null)
  1665.                         break;
  1666.                 }
  1667.             }
  1668.             return serviceEndpoints;
  1669.         }
  1670.        
  1671.         private ArrayList ResolveWsdlMethodInfo(WsdlBinding binding)
  1672.         {
  1673.             Util.Log("WsdlParser.ResolveWsdlMethodInfo " + binding.name);
  1674.             ArrayList methodInfos = new ArrayList(10);
  1675.             Hashtable propertyMethod = new Hashtable(3);
  1676.             for (int i = 0; i < binding.operations.Count; i++) {
  1677.                 bool bGet = false;
  1678.                 bool bSet = false;
  1679.                 WsdlBindingOperation op = (WsdlBindingOperation)binding.operations[i];
  1680.                 if (op.soapOperation != null) {
  1681.                     WsdlMethodInfo methodInfo = new WsdlMethodInfo();
  1682.                     methodInfo.methodName = op.name;
  1683.                     methodInfo.methodNameNs = op.nameNs;
  1684.                     methodInfo.methodAttributes = op.methodAttributes;
  1685.                     AddNewNamespace(op.nameNs);
  1686.                     WsdlBindingSoapOperation opSoap = (WsdlBindingSoapOperation)op.soapOperation;
  1687.                    
  1688.                     if ((methodInfo.methodName.StartsWith("get_", StringComparison.Ordinal) && methodInfo.methodName.Length > 4))
  1689.                         bGet = true;
  1690.                     else if ((methodInfo.methodName.StartsWith("set_", StringComparison.Ordinal) && methodInfo.methodName.Length > 4))
  1691.                         bSet = true;
  1692.                     if (bGet || bSet) {
  1693.                         bool bNew = false;
  1694.                         string propertyName = methodInfo.methodName.Substring(4);
  1695.                         WsdlMethodInfo propertyMethodInfo = (WsdlMethodInfo)propertyMethod[propertyName];
  1696.                         if (propertyMethodInfo == null) {
  1697.                             propertyMethod[propertyName] = methodInfo;
  1698.                             methodInfos.Add(methodInfo);
  1699.                             propertyMethodInfo = methodInfo;
  1700.                             methodInfo.propertyName = propertyName;
  1701.                             methodInfo.bProperty = true;
  1702.                             bNew = true;
  1703.                         }
  1704.                        
  1705.                         if (bGet) {
  1706.                             propertyMethodInfo.bGet = true;
  1707.                             propertyMethodInfo.soapActionGet = opSoap.soapAction;
  1708.                         }
  1709.                         else {
  1710.                             propertyMethodInfo.bSet = true;
  1711.                             propertyMethodInfo.soapActionSet = opSoap.soapAction;
  1712.                             //propertyMethodInfo.Dump();
  1713.                         }
  1714.                        
  1715.                         if (!bNew)
  1716.                             continue;
  1717.                         //already processed this property
  1718.                     }
  1719.                     else
  1720.                         methodInfos.Add(methodInfo);
  1721.                     methodInfo.soapAction = opSoap.soapAction;
  1722.                    
  1723.                     WsdlPortType portType = (WsdlPortType)wsdlPortTypes[binding.type];
  1724.                    
  1725.                     if ((portType == null) || (portType.operations.Count != binding.operations.Count)) {
  1726.                         throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_WsdlInvalidPortType"), binding.type));
  1727.                     }
  1728.                    
  1729.                     // PortType operations are obtained by the <binding><operation><input name = porttype operation>
  1730.                    
  1731.                     WsdlPortTypeOperation portTypeOp = null;
  1732.                     foreach (WsdlBindingOperationSection opSec in op.sections) {
  1733.                         if (MatchingStrings(opSec.elementName, s_inputString)) {
  1734.                            
  1735.                             portTypeOp = (WsdlPortTypeOperation)portType.sections[opSec.name];
  1736.                            
  1737.                             Util.Log("WsdlParser.ResolveWsdlMethodInfo find portTypeOp 1 " + opSec.name + " portTypeOp " + portTypeOp);
  1738.                            
  1739.                             if (portTypeOp == null) {
  1740.                                 int index = opSec.name.LastIndexOf("Request");
  1741.                                 if (index > 0) {
  1742.                                     string newOpName = opSec.name.Substring(0, index);
  1743.                                     portTypeOp = (WsdlPortTypeOperation)portType.sections[newOpName];
  1744.                                     Util.Log("WsdlParser.ResolveWsdlMethodInfo find portTypeOp 2 " + newOpName + " portTypeOp " + portTypeOp);
  1745.                                 }
  1746.                             }
  1747.                            
  1748.                             if (portTypeOp != null && portTypeOp.parameterOrder != null && portTypeOp.parameterOrder.Length > 0) {
  1749.                                 methodInfo.paramNamesOrder = portTypeOp.parameterOrder.Split(' ');
  1750.                             }
  1751.                            
  1752.                             foreach (WsdlBindingSoapBody body in opSec.extensions) {
  1753.                                 if (body.namespaceUri != null || body.namespaceUri.Length > 0)
  1754.                                     methodInfo.inputMethodNameNs = body.namespaceUri;
  1755.                             }
  1756.                         }
  1757.                         else if (MatchingStrings(opSec.elementName, s_outputString)) {
  1758.                             foreach (WsdlBindingSoapBody body in opSec.extensions) {
  1759.                                 if (body.namespaceUri != null || body.namespaceUri.Length > 0)
  1760.                                     methodInfo.outputMethodNameNs = body.namespaceUri;
  1761.                             }
  1762.                         }
  1763.                     }
  1764.                    
  1765.                     /*
  1766.                     if (portTypeOp == null)
  1767.                     {
  1768.                     throw new SUDSParserException(
  1769.                     String.Format(CoreChannel.GetResourceString("Remoting_Suds_WsdlInvalidPortType"),
  1770.                     binding.type));
  1771.                     }
  1772.                     */                   
  1773.                    
  1774. if (portTypeOp != null) {
  1775.                        
  1776.                         foreach (WsdlPortTypeOperationContent content in portTypeOp.contents) {
  1777.                             if (MatchingStrings(content.element, s_inputString)) {
  1778.                                 methodInfo.inputMethodName = content.message;
  1779.                                 if (methodInfo.inputMethodNameNs == null)
  1780.                                     methodInfo.inputMethodNameNs = content.messageNs;
  1781.                                 WsdlMessage message = (WsdlMessage)wsdlMessages[content.message];
  1782.                                 if (message == null) {
  1783.                                     throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_WsdlMissingMessage"), content.message));
  1784.                                 }
  1785.                                 else {
  1786.                                     if (message.parts != null) {
  1787.                                         methodInfo.inputNames = new string[message.parts.Count];
  1788.                                         methodInfo.inputNamesNs = new string[message.parts.Count];
  1789.                                         methodInfo.inputElements = new string[message.parts.Count];
  1790.                                         methodInfo.inputElementsNs = new string[message.parts.Count];
  1791.                                         methodInfo.inputTypes = new string[message.parts.Count];
  1792.                                         methodInfo.inputTypesNs = new string[message.parts.Count];
  1793.                                         for (int ip = 0; ip < message.parts.Count; ip++) {
  1794.                                             methodInfo.inputNames[ip] = ((WsdlMessagePart)message.parts[ip]).name;
  1795.                                             methodInfo.inputNamesNs[ip] = ((WsdlMessagePart)message.parts[ip]).nameNs;
  1796.                                             AddNewNamespace(methodInfo.inputNamesNs[ip]);
  1797.                                             methodInfo.inputElements[ip] = ((WsdlMessagePart)message.parts[ip]).element;
  1798.                                             methodInfo.inputElementsNs[ip] = ((WsdlMessagePart)message.parts[ip]).elementNs;
  1799.                                             AddNewNamespace(methodInfo.inputElementsNs[ip]);
  1800.                                             methodInfo.inputTypes[ip] = ((WsdlMessagePart)message.parts[ip]).typeName;
  1801.                                             methodInfo.inputTypesNs[ip] = ((WsdlMessagePart)message.parts[ip]).typeNameNs;
  1802.                                             AddNewNamespace(methodInfo.inputTypesNs[ip]);
  1803.                                             if (methodInfo.bProperty && methodInfo.inputTypes[ip] != null && methodInfo.propertyType == null) {
  1804.                                                 methodInfo.propertyType = methodInfo.inputTypes[ip];
  1805.                                                 methodInfo.propertyNs = methodInfo.inputTypesNs[ip];
  1806.                                                 AddNewNamespace(methodInfo.propertyNs);
  1807.                                             }
  1808.                                            
  1809.                                         }
  1810.                                     }
  1811.                                 }
  1812.                             }
  1813.                             else if (MatchingStrings(content.element, s_outputString)) {
  1814.                                 methodInfo.outputMethodName = content.message;
  1815.                                 if (methodInfo.outputMethodNameNs == null)
  1816.                                     methodInfo.outputMethodNameNs = content.messageNs;
  1817.                                 WsdlMessage message = (WsdlMessage)wsdlMessages[content.message];
  1818.                                 if (message == null) {
  1819.                                     throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_WsdlMissingMessage"), content.message));
  1820.                                 }
  1821.                                 else {
  1822.                                     if (message.parts != null) {
  1823.                                         methodInfo.outputNames = new string[message.parts.Count];
  1824.                                         methodInfo.outputNamesNs = new string[message.parts.Count];
  1825.                                         methodInfo.outputElements = new string[message.parts.Count];
  1826.                                         methodInfo.outputElementsNs = new string[message.parts.Count];
  1827.                                         methodInfo.outputTypes = new string[message.parts.Count];
  1828.                                         methodInfo.outputTypesNs = new string[message.parts.Count];
  1829.                                         for (int ip = 0; ip < message.parts.Count; ip++) {
  1830.                                             methodInfo.outputNames[ip] = ((WsdlMessagePart)message.parts[ip]).name;
  1831.                                             methodInfo.outputNamesNs[ip] = ((WsdlMessagePart)message.parts[ip]).nameNs;
  1832.                                             AddNewNamespace(methodInfo.outputNamesNs[ip]);
  1833.                                             methodInfo.outputElements[ip] = ((WsdlMessagePart)message.parts[ip]).element;
  1834.                                             methodInfo.outputElementsNs[ip] = ((WsdlMessagePart)message.parts[ip]).elementNs;
  1835.                                             AddNewNamespace(methodInfo.outputElementsNs[ip]);
  1836.                                             methodInfo.outputTypes[ip] = ((WsdlMessagePart)message.parts[ip]).typeName;
  1837.                                             methodInfo.outputTypesNs[ip] = ((WsdlMessagePart)message.parts[ip]).typeNameNs;
  1838.                                             AddNewNamespace(methodInfo.outputTypesNs[ip]);
  1839.                                             if (methodInfo.bProperty && methodInfo.outputTypes[ip] != null && methodInfo.propertyType == null) {
  1840.                                                 methodInfo.propertyType = methodInfo.outputTypes[ip];
  1841.                                                 methodInfo.propertyNs = methodInfo.outputTypesNs[ip];
  1842.                                                 AddNewNamespace(methodInfo.outputTypesNs[ip]);
  1843.                                             }
  1844.                                         }
  1845.                                     }
  1846.                                 }
  1847.                             }
  1848.                             else
  1849.                                 throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_WsdlInvalidPortType"), content.element));
  1850.                         }
  1851.                         //methodInfo.Dump();
  1852.                     }
  1853.                     //no porttype
  1854.                 }
  1855.             }
  1856.             return methodInfos;
  1857.         }
  1858.        
  1859.         // Parse Schema
  1860.         private void ParseSchema()
  1861.         {
  1862.             Util.Log("WsdlParser.ParseSchema");
  1863.             // Remember the current depth
  1864.             int curDepth = _XMLReader.Depth;
  1865.            
  1866.             // Parse the target namespace first
  1867.             URTNamespace parsingNamespace = ParseNamespace();
  1868.            
  1869.             // Parse schema elements
  1870.             while (_XMLReader.Depth > curDepth) {
  1871.                 string elementName = _XMLReader.LocalName;
  1872.                 //if (MatchingSchemaNamespace())
  1873.                 {
  1874.                     if (MatchingStrings(elementName, s_complexTypeString))
  1875.                         ParseComplexType(parsingNamespace, null);
  1876.                     else if (MatchingStrings(elementName, s_simpleTypeString))
  1877.                         ParseSimpleType(parsingNamespace, null);
  1878.                     else if (MatchingStrings(elementName, s_schemaString))
  1879.                         ParseSchema();
  1880.                     else if (MatchingStrings(elementName, s_elementString))
  1881.                         ParseElementDecl(parsingNamespace);
  1882.                     else if (MatchingStrings(elementName, s_importString))
  1883.                         ParseSchemaImportElement();
  1884.                     else if (MatchingStrings(elementName, s_includeString))
  1885.                         ParseSchemaIncludeElement();
  1886.                     else
  1887.                         goto SkipXMLNode;
  1888.                    
  1889.                     continue;
  1890.                 }
  1891.                 SkipXMLNode:
  1892.                
  1893.                 // Ignore others elements such as annotations
  1894.                 SkipXmlElement();
  1895.             }
  1896.            
  1897.             return;
  1898.         }
  1899.        
  1900.        
  1901.         // Resolves internal references
  1902.         private void Resolve()
  1903.         {
  1904.             Util.Log("WsdlParser.Resolve");
  1905.             for (int i = 0; i < _URTNamespaces.Count; i++)
  1906.                 ((URTNamespace)_URTNamespaces[i]).ResolveElements(this);
  1907.            
  1908.             for (int i = 0; i < _URTNamespaces.Count; i++)
  1909.                 ((URTNamespace)_URTNamespaces[i]).ResolveTypes(this);
  1910.            
  1911.             for (int i = 0; i < _URTNamespaces.Count; i++)
  1912.                 ((URTNamespace)_URTNamespaces[i]).ResolveMethods();
  1913.         }
  1914.        
  1915.         // Lookup a given attribute position.
  1916.         // Note that the supplied strings must have been atomized
  1917.         private string LookupAttribute(string attrName, string attrNS, bool throwExp)
  1918.         {
  1919.             Util.Log("WsdlParser.LookupAttribute Enter " + attrName + ", NS " + attrNS + ", Exp " + throwExp);
  1920.             string value = s_emptyString;
  1921.             bool bPresent;
  1922.             if (attrNS != null)
  1923.                 bPresent = _XMLReader.MoveToAttribute(attrName, attrNS);
  1924.             else
  1925.                 bPresent = _XMLReader.MoveToAttribute(attrName);
  1926.            
  1927.             if (bPresent)
  1928.                 value = Atomize(_XMLReader.Value.Trim());
  1929.             _XMLReader.MoveToElement();
  1930.            
  1931.             if ((bPresent == false) && (throwExp == true)) {
  1932.                 throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_AttributeNotFound"), attrName, XMLReader.LineNumber, XMLReader.LinePosition, XMLReader.Name));
  1933.             }
  1934.             Util.Log("WsdlParser.LookupAttribute exit " + attrName + "=" + value + ", NS " + attrNS + ", Exp " + throwExp);
  1935.             return (value);
  1936.         }
  1937.        
  1938.         // Resolves type attribute into its constituent parts
  1939.         private void ResolveTypeAttribute(ref string typeName, out string typeNS, out bool bEmbedded, out bool bPrimitive)
  1940.         {
  1941.             Util.Log("WsdlParser.ResolveTypeAttribute typeName " + typeName);
  1942.             if (MatchingStrings(typeName, s_emptyString)) {
  1943.                 typeName = s_objectString;
  1944.                 typeNS = SchemaNamespaceString;
  1945.                 bEmbedded = true;
  1946.                 bPrimitive = false;
  1947.             }
  1948.             else {
  1949.                 // The type field is a QName
  1950.                 typeNS = ParseQName(ref typeName);
  1951.                
  1952.                 // Check for reference and array types
  1953.                 ResolveTypeNames(ref typeNS, ref typeName, out bEmbedded, out bPrimitive);
  1954.             }
  1955.            
  1956.             return;
  1957.         }
  1958.        
  1959.         // Parses a qname
  1960.        
  1961.         private string ParseQName(ref string qname)
  1962.         {
  1963.             return ParseQName(ref qname, null);
  1964.         }
  1965.         private string ParseQName(ref string qname, URTNamespace defaultNS)
  1966.         {
  1967.             URTNamespace returnNS = null;
  1968.             return ParseQName(ref qname, defaultNS, out returnNS);
  1969.         }
  1970.        
  1971.         private string ParseQName(ref string qname, URTNamespace defaultNS, out URTNamespace returnNS)
  1972.         {
  1973.             Util.Log("WsdlParser.ParseQName Enter qname " + qname + " default xmlns NS " + _XMLReader.LookupNamespace(""));
  1974.            
  1975.             string ns = null;
  1976.             returnNS = null;
  1977.             if ((qname == null) || (qname.Length == 0)) {
  1978.                 Util.Log("WsdlParser.ParseQName Exit null");
  1979.                 return null;
  1980.             }
  1981.            
  1982.             int colonIndex = qname.IndexOf(":");
  1983.             if (colonIndex == -1) {
  1984.                 // The default namespace is the s_empty string (this will need to change)
  1985.                 //textWriter.WriteLine("DefaultNS: " + _XMLReader.LookupNamespace(s_emptyString) + '\n' +
  1986.                 // "ElementNS: " + _XMLReader.Namespace);
  1987.                 // Should this be element namespace or default namespace
  1988.                 // For attributes names, element namespace makes more sense
  1989.                 // For QName values, default namespace makes more sense
  1990.                 // I am currently returning default namespace
  1991.                
  1992.                 returnNS = defaultNS;
  1993.                 if (defaultNS == null) {
  1994.                     Util.Log("WsdlParser.ParseQName Exit defaultNS qname " + qname);
  1995.                     ns = _XMLReader.LookupNamespace("");
  1996.                 }
  1997.                 else {
  1998.                     Util.Log("WsdlParser.ParseQName Exit defaultNS qname " + qname + " default " + defaultNS.Name);
  1999.                     ns = defaultNS.Name;
  2000.                 }
  2001.                
  2002.             }
  2003.             else {
  2004.                 // Get the suffix and atmoize it
  2005.                 string prefix = qname.Substring(0, colonIndex);
  2006.                 qname = Atomize(qname.Substring(colonIndex + 1));
  2007.                 ns = _XMLReader.LookupNamespace(prefix);
  2008.             }
  2009.            
  2010.             ns = Atomize(ns);
  2011.            
  2012.             URTNamespace xns = LookupNamespace(ns);
  2013.            
  2014.             if (xns == null) {
  2015.                 xns = new URTNamespace(ns, this);
  2016.             }
  2017.            
  2018.            
  2019.             returnNS = xns;
  2020.            
  2021.             Util.Log("WsdlParser.ParseQName Exit qname " + qname + " typeString " + ns + " returnNS " + (returnNS == null ? "null" : returnNS.Name));
  2022.             return (ns);
  2023.         }
  2024.        
  2025.         // Returns true if the type needs to be qualified with namespace
  2026.         private bool Qualify(string typeNS, string curNS)
  2027.         {
  2028.             Util.Log("WsdlParser.Qualify typeNS " + typeNS + " curNS " + curNS);
  2029.             if (MatchingSchemaStrings(typeNS) || MatchingStrings(typeNS, s_soapNamespaceString) || MatchingStrings(typeNS, s_wsdlSoapNamespaceString) || MatchingStrings(typeNS, "System") || MatchingStrings(typeNS, curNS))
  2030.                 return (false);
  2031.            
  2032.             return (true);
  2033.         }
  2034.        
  2035.         // Returns true if the current element node namespace has matching namespace
  2036.         private bool MatchingNamespace(string elmNS)
  2037.         {
  2038.             Util.Log("WsdlParser.MatchingNamespace " + elmNS + " ***** " + _XMLReader.NamespaceURI);
  2039.             if (MatchingStrings(_XMLReader.NamespaceURI, elmNS))
  2040.                 // ||
  2041.                 // MatchingStrings(_XMLReader.Prefix, s_emptyString))
  2042.                 return (true);
  2043.            
  2044.             return (false);
  2045.         }
  2046.        
  2047.         private bool MatchingSchemaNamespace()
  2048.         {
  2049.             Util.Log("WsdlParser.MatchingSchemaNamespace ");
  2050.             if (MatchingNamespace(s_schemaNamespaceString))
  2051.                 return true;
  2052.             else if (MatchingNamespace(s_schemaNamespaceString1999)) {
  2053.                 _xsdVersion = XsdVersion.V1999;
  2054.                 return true;
  2055.             }
  2056.             else if (MatchingNamespace(s_schemaNamespaceString2000)) {
  2057.                 _xsdVersion = XsdVersion.V2000;
  2058.                 return true;
  2059.             }
  2060.             else if (MatchingNamespace(s_schemaNamespaceString)) {
  2061.                 _xsdVersion = XsdVersion.V2001;
  2062.                 return true;
  2063.             }
  2064.             else {
  2065.                 return false;
  2066.             }
  2067.         }
  2068.        
  2069.         static StringBuilder vsb = new StringBuilder();
  2070.         static internal string IsValidUrl(string value)
  2071.         {
  2072.             if (value == null) {
  2073.                 return "\"\"";
  2074.             }
  2075.            
  2076.             vsb.Length = 0;
  2077.             vsb.Append("@\"");
  2078.            
  2079.             for (int i = 0; i < value.Length; i++) {
  2080.                 if (value[i] == '"')
  2081.                     vsb.Append("\"\"");
  2082.                 else
  2083.                     vsb.Append(value[i]);
  2084.             }
  2085.            
  2086.             vsb.Append("\"");
  2087.             return vsb.ToString();
  2088.         }
  2089.        
  2090.        
  2091.         static Hashtable cSharpKeywords;
  2092.         static bool IsCSharpKeyword(string value)
  2093.         {
  2094.             if (cSharpKeywords == null)
  2095.                 InitKeywords();
  2096.             return cSharpKeywords.ContainsKey(value);
  2097.         }
  2098.        
  2099.         static void InitKeywords()
  2100.         {
  2101.             // build the cSharpKeywords hashtable
  2102.             Hashtable cSharpKeywordstemp = new Hashtable(75);
  2103.             // about 75 cSharpKeywords to be added
  2104.             object obj = new object();
  2105.             cSharpKeywordstemp["abstract"] = obj;
  2106.             cSharpKeywordstemp["base"] = obj;
  2107.             cSharpKeywordstemp["bool"] = obj;
  2108.             cSharpKeywordstemp["break"] = obj;
  2109.             cSharpKeywordstemp["byte"] = obj;
  2110.             cSharpKeywordstemp["case"] = obj;
  2111.             cSharpKeywordstemp["catch"] = obj;
  2112.             cSharpKeywordstemp["char"] = obj;
  2113.             cSharpKeywordstemp["checked"] = obj;
  2114.             cSharpKeywordstemp["class"] = obj;
  2115.             cSharpKeywordstemp["const"] = obj;
  2116.             cSharpKeywordstemp["continue"] = obj;
  2117.             cSharpKeywordstemp["decimal"] = obj;
  2118.             cSharpKeywordstemp["default"] = obj;
  2119.             cSharpKeywordstemp["delegate"] = obj;
  2120.             cSharpKeywordstemp["do"] = obj;
  2121.             cSharpKeywordstemp["double"] = obj;
  2122.             cSharpKeywordstemp["else"] = obj;
  2123.             cSharpKeywordstemp["enum"] = obj;
  2124.             cSharpKeywordstemp["event"] = obj;
  2125.             cSharpKeywordstemp["exdouble"] = obj;
  2126.             cSharpKeywordstemp["exfloat"] = obj;
  2127.             cSharpKeywordstemp["explicit"] = obj;
  2128.             cSharpKeywordstemp["extern"] = obj;
  2129.             cSharpKeywordstemp["false"] = obj;
  2130.             cSharpKeywordstemp["finally"] = obj;
  2131.             cSharpKeywordstemp["fixed"] = obj;
  2132.             cSharpKeywordstemp["float"] = obj;
  2133.             cSharpKeywordstemp["for"] = obj;
  2134.             cSharpKeywordstemp["foreach"] = obj;
  2135.             cSharpKeywordstemp["goto"] = obj;
  2136.             cSharpKeywordstemp["if"] = obj;
  2137.             cSharpKeywordstemp["implicit"] = obj;
  2138.             cSharpKeywordstemp["in"] = obj;
  2139.             cSharpKeywordstemp["int"] = obj;
  2140.             cSharpKeywordstemp["interface"] = obj;
  2141.             cSharpKeywordstemp["internal"] = obj;
  2142.             cSharpKeywordstemp["is"] = obj;
  2143.             cSharpKeywordstemp["lock"] = obj;
  2144.             cSharpKeywordstemp["long"] = obj;
  2145.             cSharpKeywordstemp["namespace"] = obj;
  2146.             cSharpKeywordstemp["new"] = obj;
  2147.             cSharpKeywordstemp["null"] = obj;
  2148.             cSharpKeywordstemp["object"] = obj;
  2149.             cSharpKeywordstemp["operator"] = obj;
  2150.             cSharpKeywordstemp["out"] = obj;
  2151.             cSharpKeywordstemp["override"] = obj;
  2152.             cSharpKeywordstemp["private"] = obj;
  2153.             cSharpKeywordstemp["protected"] = obj;
  2154.             cSharpKeywordstemp["public"] = obj;
  2155.             cSharpKeywordstemp["readonly"] = obj;
  2156.             cSharpKeywordstemp["ref"] = obj;
  2157.             cSharpKeywordstemp["return"] = obj;
  2158.             cSharpKeywordstemp["sbyte"] = obj;
  2159.             cSharpKeywordstemp["sealed"] = obj;
  2160.             cSharpKeywordstemp["short"] = obj;
  2161.             cSharpKeywordstemp["sizeof"] = obj;
  2162.             cSharpKeywordstemp["static"] = obj;
  2163.             cSharpKeywordstemp["string"] = obj;
  2164.             cSharpKeywordstemp["struct"] = obj;
  2165.             cSharpKeywordstemp["switch"] = obj;
  2166.             cSharpKeywordstemp["this"] = obj;
  2167.             cSharpKeywordstemp["throw"] = obj;
  2168.             cSharpKeywordstemp["true"] = obj;
  2169.             cSharpKeywordstemp["try"] = obj;
  2170.             cSharpKeywordstemp["typeof"] = obj;
  2171.             cSharpKeywordstemp["uint"] = obj;
  2172.             cSharpKeywordstemp["ulong"] = obj;
  2173.             cSharpKeywordstemp["unchecked"] = obj;
  2174.             cSharpKeywordstemp["unsafe"] = obj;
  2175.             cSharpKeywordstemp["ushort"] = obj;
  2176.             cSharpKeywordstemp["using"] = obj;
  2177.             cSharpKeywordstemp["virtual"] = obj;
  2178.             cSharpKeywordstemp["void"] = obj;
  2179.             cSharpKeywordstemp["while"] = obj;
  2180.             cSharpKeywords = cSharpKeywordstemp;
  2181.         }
  2182.        
  2183.        
  2184.        
  2185.         static bool IsValidLanguageIndependentIdentifier(string ident)
  2186.         {
  2187.             for (int i = 0; i < ident.Length; i++) {
  2188.                 char c = ident[i];
  2189.                 UnicodeCategory uc = Char.GetUnicodeCategory(c);
  2190.                 // each char must be Lu, Ll, Lt, Lm, Lo, Nd, Mn, Mc, Pc
  2191.                 //
  2192.                 switch (uc) {
  2193.                     case UnicodeCategory.UppercaseLetter:
  2194.                     case UnicodeCategory.LowercaseLetter:
  2195.                     case UnicodeCategory.TitlecaseLetter:
  2196.                     case UnicodeCategory.ModifierLetter:
  2197.                     case UnicodeCategory.OtherLetter:
  2198.                     case UnicodeCategory.DecimalDigitNumber:
  2199.                     case UnicodeCategory.NonSpacingMark:
  2200.                     case UnicodeCategory.SpacingCombiningMark:
  2201.                     case UnicodeCategory.ConnectorPunctuation:
  2202.                         // Lu
  2203.                         // Ll
  2204.                         // Lt
  2205.                         // Lm
  2206.                         // Lo
  2207.                         // Nd
  2208.                         // Mn
  2209.                         // Mc
  2210.                         // Pc
  2211.                         break;
  2212.                     case UnicodeCategory.LetterNumber:
  2213.                     case UnicodeCategory.OtherNumber:
  2214.                     case UnicodeCategory.EnclosingMark:
  2215.                     case UnicodeCategory.SpaceSeparator:
  2216.                     case UnicodeCategory.LineSeparator:
  2217.                     case UnicodeCategory.ParagraphSeparator:
  2218.                     case UnicodeCategory.Control:
  2219.                     case UnicodeCategory.Format:
  2220.                     case UnicodeCategory.Surrogate:
  2221.                     case UnicodeCategory.PrivateUse:
  2222.                     case UnicodeCategory.DashPunctuation:
  2223.                     case UnicodeCategory.OpenPunctuation:
  2224.                     case UnicodeCategory.ClosePunctuation:
  2225.                     case UnicodeCategory.InitialQuotePunctuation:
  2226.                     case UnicodeCategory.FinalQuotePunctuation:
  2227.                     case UnicodeCategory.OtherPunctuation:
  2228.                     case UnicodeCategory.MathSymbol:
  2229.                     case UnicodeCategory.CurrencySymbol:
  2230.                     case UnicodeCategory.ModifierSymbol:
  2231.                     case UnicodeCategory.OtherSymbol:
  2232.                     case UnicodeCategory.OtherNotAssigned:
  2233.                         return false;
  2234.                     default:
  2235.                         return false;
  2236.                 }
  2237.             }
  2238.             return true;
  2239.         }
  2240.        
  2241.        
  2242.         static internal void CheckValidIdentifier(string ident)
  2243.         {
  2244.             if (!IsValidLanguageIndependentIdentifier(ident))
  2245.                 throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_WsdlInvalidStringSyntax"), ident));
  2246.         }
  2247.        
  2248.         // Used when identifier appears in a custom attribute. Need to strip out leading @ for keyword
  2249.         static internal string IsValidCSAttr(string identifier)
  2250.         {
  2251.             string returnstr = IsValidCS(identifier);
  2252.             if (returnstr.Length > 0 && returnstr[0] == '@')
  2253.                 return returnstr.Substring(1);
  2254.             else
  2255.                 return returnstr;
  2256.         }
  2257.        
  2258.         static internal string IsValidCS(string identifier)
  2259.         {
  2260.             if (identifier == null || identifier.Length == 0 || identifier == " ")
  2261.                 return identifier;
  2262.             string originalIdentifier = identifier;
  2263.             int index = identifier.IndexOf('[');
  2264.             string arraybrackets = null;
  2265.             if (index > -1) {
  2266.                 arraybrackets = identifier.Substring(index);
  2267.                 identifier = identifier.Substring(0, index);
  2268.                 // Check arraybrackets
  2269.                 for (int i = 0; i < arraybrackets.Length; i++) {
  2270.                     switch (arraybrackets[i]) {
  2271.                         case '[':
  2272.                         case ']':
  2273.                         case ',':
  2274.                         case ' ':
  2275.                             break;
  2276.                         default:
  2277.                             throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_WsdlInvalidStringSyntax"), identifier));
  2278.                             break;
  2279.                     }
  2280.                 }
  2281.             }
  2282.            
  2283.             string[] names = identifier.Split(new char[] {'.'});
  2284.             bool newIdent = false;
  2285.             StringBuilder sb = new StringBuilder();
  2286.            
  2287.             for (int i = 0; i < names.Length; i++) {
  2288.                 if (i > 0)
  2289.                     sb.Append(".");
  2290.                 if (IsCSharpKeyword(names[i])) {
  2291.                     sb.Append("@");
  2292.                     newIdent = true;
  2293.                 }
  2294.                 CheckValidIdentifier(names[i]);
  2295.                 sb.Append(names[i]);
  2296.             }
  2297.            
  2298.             if (newIdent) {
  2299.                 if (arraybrackets != null)
  2300.                     sb.Append(arraybrackets);
  2301.                 return sb.ToString();
  2302.             }
  2303.             return originalIdentifier;
  2304.         }
  2305.        
  2306.        
  2307.         // Returns true if the atomized strings match
  2308.         private static bool MatchingStrings(string left, string right)
  2309.         {
  2310.             //Util.Log("WsdlParser.MatchingStrings left "+left+" right "+right);
  2311.             return ((object)left == (object)right);
  2312.         }
  2313.        
  2314.         private bool MatchingSchemaStrings(string left)
  2315.         {
  2316.             Util.Log("WsdlParser.MatchingSchemaStrings left " + left + " _xsdVersion " + ((Enum)_xsdVersion).ToString());
  2317.            
  2318.             if (MatchingStrings(left, s_schemaNamespaceString1999)) {
  2319.                 _xsdVersion = XsdVersion.V1999;
  2320.                 return true;
  2321.             }
  2322.             else if (MatchingStrings(left, s_schemaNamespaceString2000)) {
  2323.                 _xsdVersion = XsdVersion.V2000;
  2324.                 return true;
  2325.             }
  2326.             else if (MatchingStrings(left, s_schemaNamespaceString)) {
  2327.                 _xsdVersion = XsdVersion.V2001;
  2328.                 return true;
  2329.             }
  2330.             else
  2331.                 return false;
  2332.         }
  2333.        
  2334.         // Atmozie the given string
  2335.         internal string Atomize(string str)
  2336.         {
  2337.             // Always atmoize using the table defined on the
  2338.             // current XML parser
  2339.             return (_XMLReader.NameTable.Add(str));
  2340.         }
  2341.        
  2342.         // Maps URT types to CSharp types
  2343.         private string MapSchemaTypesToCSharpTypes(string xsdType)
  2344.         {
  2345.             Util.Log("SudsConverter.MapSchemaTypesToCSharpTypes Enter " + xsdType);
  2346.             string stype = xsdType;
  2347.             int index = xsdType.IndexOf('[');
  2348.             if (index != -1)
  2349.                 stype = xsdType.Substring(0, index);
  2350.            
  2351.             string clrType = SudsConverter.MapXsdToClrTypes(stype);
  2352.            
  2353.             if (clrType == null)
  2354.                 throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), xsdType, s_schemaNamespaceString));
  2355.            
  2356.             // Handle array types
  2357.             if (index != -1)
  2358.                 clrType = clrType + xsdType.Substring(index);
  2359.             Util.Log("SudsConverter.MapSchemaTypesToCSharpTypes Exit Type " + clrType);
  2360.            
  2361.             return clrType;
  2362.         }
  2363.        
  2364.         // Return true if the given type is a primitive type
  2365.         private bool IsPrimitiveType(string typeNS, string typeName)
  2366.         {
  2367.             Util.Log("WsdlParser.IsPrimitiveType typeNS " + typeNS + " typeName " + typeName);
  2368.             bool fReturn = false;
  2369.             if (MatchingSchemaStrings(typeNS)) {
  2370.                 if (!MatchingStrings(typeName, s_urTypeString))
  2371.                     fReturn = true;
  2372.             }
  2373.            
  2374.             return (fReturn);
  2375.         }
  2376.        
  2377.         // Looksup a matching namespace
  2378.         private URTNamespace LookupNamespace(string name)
  2379.         {
  2380.             Util.Log("WsdlParser.lookupNamespace name " + name + " number of NS " + _URTNamespaces.Count);
  2381.             for (int i = 0; i < _URTNamespaces.Count; i++) {
  2382.                 URTNamespace urtNS = (URTNamespace)_URTNamespaces[i];
  2383.                 //Util.Log("WsdlParser.lookupNamespace search ns "+urtNS.Name+" input "+name);
  2384.                 //if (urtNS.Name == name)
  2385.                 if (WsdlParser.MatchingStrings(urtNS.Name, name)) {
  2386.                     Util.Log("WsdlParser.lookupNamespace search ns found " + urtNS.GetHashCode() + " " + urtNS.Name + " input " + name);
  2387.                     return (urtNS);
  2388.                 }
  2389.             }
  2390.            
  2391.             Util.Log("WsdlParser.lookupNamespace search ns Not found " + name);
  2392.             return (null);
  2393.         }
  2394.        
  2395.         // This routine is used when finding and creating namespaces during the resolve phase.
  2396.         // These references are from binding section which support encoded rpc. Any namespace
  2397.         // not referenced during this phase will be pruned before creating proxy. This will
  2398.         // prevent Types not used from being placed in the proxy.
  2399.        
  2400.         internal URTNamespace AddNewNamespace(string ns)
  2401.         {
  2402.             Util.Log("WsdlParser.AddNewNamespace name " + ns);
  2403.             if (ns == null)
  2404.                 return null;
  2405.            
  2406.             URTNamespace xns = LookupNamespace(ns);
  2407.             if (xns == null) {
  2408.                 xns = new URTNamespace(ns, this);
  2409.                 Util.Log("WsdlParser.AddNewNamespace new namespace " + ns);
  2410.             }
  2411.             else {
  2412.                 Util.Log("WsdlParser.AddNewNamespace existing namespace " + ns);
  2413.             }
  2414.             if (!xns.IsSystem)
  2415.                 xns.bReferenced = true;
  2416.             return xns;
  2417.         }
  2418.        
  2419.         internal void AddNamespace(URTNamespace xns)
  2420.         {
  2421.             //Util.Log("WsdlParser.AddNamespace "+xns.GetHashCode()+" "+xns.Namespace);
  2422.             _URTNamespaces.Add(xns);
  2423.         }
  2424.        
  2425.         // Prints the parsed entities
  2426.         private void PrintCSC()
  2427.         {
  2428.             Util.Log("WsdlParser.PrintCSC ");
  2429.             int interopCount = 0;
  2430.            
  2431.             // For interop, recalculate the interop names
  2432.             for (int i = 0; i < _URTNamespaces.Count; i++) {
  2433.                 URTNamespace urtNS = (URTNamespace)_URTNamespaces[i];
  2434.                 if (!urtNS.IsEmpty && urtNS.UrtType == UrtType.Interop) {
  2435.                     if (interopCount == 0)
  2436.                         urtNS.EncodedNS = _proxyNamespace;
  2437.                     else
  2438.                         urtNS.EncodedNS = _proxyNamespace + interopCount;
  2439.                     interopCount++;
  2440.                     Util.Log("WsdlParser.PrintCSC Interop " + urtNS.EncodedNS + " " + urtNS.Namespace + " urtType " + ((Enum)urtNS.UrtType).ToString());
  2441.                 }
  2442.             }
  2443.            
  2444.             for (int i = 0; i < _URTNamespaces.Count; i++) {
  2445.                 URTNamespace urtNS = (URTNamespace)_URTNamespaces[i];
  2446.                 if (!urtNS.IsEmpty && !(urtNS.UrtType == UrtType.UrtSystem || urtNS.UrtType == UrtType.Xsd || urtNS.UrtType == UrtType.None)) {
  2447.                     Util.Log("WsdlParser.PrintCSC fileName urtNS " + urtNS.Namespace + " urtType " + ((Enum)urtNS.UrtType).ToString());
  2448.                     string fileName = urtNS.IsURTNamespace ? urtNS.AssemName : urtNS.EncodedNS;
  2449.                     int index = fileName.IndexOf(',');
  2450.                     // reduce to simple assembly name
  2451.                     if (index > -1) {
  2452.                         fileName = fileName.Substring(0, index);
  2453.                     }
  2454.                     Util.Log("WsdlParser.PrintCSC fileName " + fileName + " " + urtNS.Namespace);
  2455.                     string completeFileName = "";
  2456.                    
  2457.                     WriterStream output = WriterStream.GetWriterStream(ref _writerStreams, _outputDir, fileName, ref completeFileName);
  2458.                     if (completeFileName.Length > 0)
  2459.                         _outCodeStreamList.Add(completeFileName);
  2460.                     urtNS.PrintCSC(output);
  2461.                 }
  2462.             }
  2463.             return;
  2464.         }
  2465.        
  2466.         internal UrtType IsURTExportedType(string name, out string ns, out string assemName)
  2467.         {
  2468.             Util.Log("WsdlParser.IsURTExportedType Enter " + name);
  2469.             //Console.WriteLine("Parsing " + name);
  2470.             UrtType urtType = UrtType.None;
  2471.             ns = null;
  2472.             assemName = null;
  2473.            
  2474.             if (MatchingSchemaStrings(name)) {
  2475.                 Util.Log("WsdlParser.IsURTExportedType trace 1 " + name);
  2476.                 urtType = UrtType.Xsd;
  2477.             }
  2478.             else {
  2479.                 Util.Log("WsdlParser.IsURTExportedType trace 2 " + name);
  2480.                 if (SoapServices.IsClrTypeNamespace(name)) {
  2481.                     SoapServices.DecodeXmlNamespaceForClrTypeNamespace(name, out ns, out assemName);
  2482.                    
  2483.                     if (assemName == null) {
  2484.                         assemName = typeof(string).Assembly.GetName().Name;
  2485.                         urtType = UrtType.UrtSystem;
  2486.                     }
  2487.                     else
  2488.                         urtType = UrtType.UrtUser;
  2489.                 }
  2490.                
  2491.                 if (urtType == UrtType.None) {
  2492.                     ns = name;
  2493.                     assemName = ns;
  2494.                     urtType = UrtType.Interop;
  2495.                 }
  2496.                
  2497.                 ns = Atomize(ns);
  2498.                 assemName = Atomize(assemName);
  2499.             }
  2500.            
  2501.             //Console.WriteLine("NS: " + ns + " Assembly: " + assemName);
  2502.             Util.Log("WsdlParser.IsURTExportedType Exit " + ((Enum)urtType).ToString());
  2503.             return (urtType);
  2504.         }
  2505.        
  2506.         internal string GetTypeString(string curNS, bool bNS, URTNamespace urtNS, string typeName, string typeNS)
  2507.         {
  2508.             Util.Log("WsdlParser.GetTypeString Entry curNS " + curNS + " bNS " + bNS + " URTNamespace " + urtNS.Name + " typeName " + typeName + " typeNS " + typeNS);
  2509.             string type;
  2510.            
  2511.             URTComplexType ct = urtNS.LookupComplexType(typeName);
  2512.             if (ct != null && ct.IsArray()) {
  2513.                 if (ct.GetArray() == null)
  2514.                     ct.ResolveArray();
  2515.                 string arrayName = ct.GetArray();
  2516.                 URTNamespace arrayNS = ct.GetArrayNS();
  2517.                 StringBuilder sb = new StringBuilder(50);
  2518.                 if (arrayNS.EncodedNS != null && Qualify(urtNS.EncodedNS, arrayNS.EncodedNS)) {
  2519.                     sb.Append(WsdlParser.IsValidCSAttr(arrayNS.EncodedNS));
  2520.                     sb.Append('.');
  2521.                 }
  2522.                 sb.Append(WsdlParser.IsValidCSAttr(arrayName));
  2523.                 type = sb.ToString();
  2524.             }
  2525.             else {
  2526.                 string encodedNS = null;
  2527.                 if (urtNS.UrtType == UrtType.Interop)
  2528.                     encodedNS = urtNS.EncodedNS;
  2529.                 else
  2530.                     encodedNS = typeNS;
  2531.                
  2532.                 if (bNS && Qualify(encodedNS, curNS)) {
  2533.                     StringBuilder sb = new StringBuilder(50);
  2534.                     if (encodedNS != null) {
  2535.                         sb.Append(WsdlParser.IsValidCSAttr(encodedNS));
  2536.                         sb.Append('.');
  2537.                     }
  2538.                     sb.Append(WsdlParser.IsValidCSAttr(typeName));
  2539.                     type = sb.ToString();
  2540.                 }
  2541.                 else {
  2542.                     type = typeName;
  2543.                 }
  2544.                
  2545.             }
  2546.            
  2547.             int index = type.IndexOf('+');
  2548.             if (index > 0) {
  2549.                 // nested type, replace + with . Should be done earlier when forming names
  2550.                 if (bNS)
  2551.                     type = type.Replace('+', '.');
  2552.                 else
  2553.                     type = type.Substring(0, index);
  2554.             }
  2555.            
  2556.            
  2557.             Util.Log("WsdlParser.GetTypeString Exit type " + type);
  2558.             return (type);
  2559.         }
  2560.        
  2561.        
  2562.         // Creates and initializes the name table if neccessary
  2563.         private static XmlNameTable CreatePrimedNametable()
  2564.         {
  2565.             Util.Log("WsdlParser.CreatePrimedNametable");
  2566.            
  2567.             //Interlocked.Increment(ref s_counter);
  2568.             /*if(s_atomizedTable == null)
  2569.             {
  2570.             // Create a new nametable
  2571.             //MTNameTable newTable = new MTNameTable(true);
  2572.             }*/           
  2573. NameTable newTable = new NameTable();
  2574.            
  2575.             // Atomically update static location to point to the current table
  2576.             /*Object oldTable = Interlocked.CompareExchange(ref s_atomizedTable, newTable, null);
  2577.             if(oldTable != null)
  2578.             newTable = (MTNameTable) oldTable; */           
  2579.            
  2580.             // Atomize frequently used strings for perf
  2581.             // The following ops are not done inside a lock as they are idempotent
  2582. s_emptyString = newTable.Add(String.Empty);
  2583.             s_complexTypeString = newTable.Add("complexType");
  2584.             s_simpleTypeString = newTable.Add("simpleType");
  2585.             s_elementString = newTable.Add("element");
  2586.             s_enumerationString = newTable.Add("enumeration");
  2587.             s_encodingString = newTable.Add("encoding");
  2588.             s_attributeString = newTable.Add("attribute");
  2589.             s_attributesString = newTable.Add("attributes");
  2590.             s_allString = newTable.Add("all");
  2591.             s_sequenceString = newTable.Add("sequence");
  2592.             s_choiceString = newTable.Add("choice");
  2593.             s_minOccursString = newTable.Add("minOccurs");
  2594.             s_maxOccursString = newTable.Add("maxOccurs");
  2595.             s_unboundedString = newTable.Add("unbounded");
  2596.             s_oneString = newTable.Add("1");
  2597.             s_zeroString = newTable.Add("0");
  2598.             s_nameString = newTable.Add("name");
  2599.             s_typeString = newTable.Add("type");
  2600.             s_baseString = newTable.Add("base");
  2601.             s_valueString = newTable.Add("value");
  2602.             s_interfaceString = newTable.Add("interface");
  2603.             s_serviceString = newTable.Add("service");
  2604.             s_extendsString = newTable.Add("extends");
  2605.             s_addressesString = newTable.Add("addresses");
  2606.             s_addressString = newTable.Add("address");
  2607.             s_uriString = newTable.Add("uri");
  2608.             s_implementsString = newTable.Add("implements");
  2609.             s_nestedTypeString = newTable.Add("nestedType");
  2610.             s_requestString = newTable.Add("request");
  2611.             s_responseString = newTable.Add("response");
  2612.             s_requestResponseString = newTable.Add("requestResponse");
  2613.             s_messageString = newTable.Add("message");
  2614.             s_locationString = newTable.Add("location");
  2615.             s_schemaLocationString = newTable.Add("schemaLocation");
  2616.             s_importString = newTable.Add("import");
  2617.             s_onewayString = newTable.Add("oneway");
  2618.             s_includeString = newTable.Add("include");
  2619.             s_refString = newTable.Add("ref");
  2620.             s_refTypeString = newTable.Add("refType");
  2621.             s_referenceString = newTable.Add("Reference");
  2622.             s_objectString = newTable.Add("Object");
  2623.             s_urTypeString = newTable.Add("anyType");
  2624.             s_arrayString = newTable.Add("Array");
  2625.             s_sudsString = newTable.Add("suds");
  2626.             s_methodString = newTable.Add("method");
  2627.             s_useString = newTable.Add("use");
  2628.             s_rootTypeString = newTable.Add("rootType");
  2629.             s_soapString = newTable.Add("soap");
  2630.             s_serviceDescString = newTable.Add("serviceDescription");
  2631.             s_schemaString = newTable.Add("schema");
  2632.             s_targetNamespaceString = newTable.Add("targetNamespace");
  2633.             s_namespaceString = newTable.Add("namespace");
  2634.             s_idString = newTable.Add("ID");
  2635.             s_soapActionString = newTable.Add("soapAction");
  2636.             s_schemaNamespaceString1999 = newTable.Add(SudsConverter.Xsd1999);
  2637.             s_instanceNamespaceString1999 = newTable.Add(SudsConverter.Xsi1999);
  2638.             s_schemaNamespaceString2000 = newTable.Add(SudsConverter.Xsd2000);
  2639.             s_instanceNamespaceString2000 = newTable.Add(SudsConverter.Xsi2000);
  2640.             s_schemaNamespaceString = newTable.Add(SudsConverter.Xsd2001);
  2641.             s_instanceNamespaceString = newTable.Add(SudsConverter.Xsi2001);
  2642.             s_soapNamespaceString = newTable.Add("urn:schemas-xmlsoap-org:soap.v1");
  2643.             //s_sudsNamespaceString = newTable.Add("urn:schemas-xmlsoap-org:suds.v1");
  2644.             s_sudsNamespaceString = newTable.Add("urn:schemas-xmlsoap-org:soap-sdl-2000-01-25");
  2645.             //s_URTNamespaceString = newTable.Add("urn:schamas-xmlsoap-org:urt.v1");
  2646.             //s_serviceNamespaceString = newTable.Add("urn:schemas-xmlsoap-org:servicedesc.v1");
  2647.             s_serviceNamespaceString = newTable.Add("urn:schemas-xmlsoap-org:sdl.2000-01-25");
  2648.            
  2649.             // Wsdl strings
  2650.             s_definitionsString = newTable.Add("definitions");
  2651.             s_wsdlNamespaceString = newTable.Add("http://schemas.xmlsoap.org/wsdl/");
  2652.             s_wsdlSoapNamespaceString = newTable.Add("http://schemas.xmlsoap.org/wsdl/soap/");
  2653.             s_wsdlSudsNamespaceString = newTable.Add("http://www.w3.org/2000/wsdl/suds");
  2654.             s_enumTypeString = newTable.Add("enumType");
  2655.             s_typesString = newTable.Add("types");
  2656.             s_partString = newTable.Add("part");
  2657.             s_portTypeString = newTable.Add("portType");
  2658.             s_operationString = newTable.Add("operation");
  2659.             s_inputString = newTable.Add("input");
  2660.             s_outputString = newTable.Add("output");
  2661.             s_bindingString = newTable.Add("binding");
  2662.             s_classString = newTable.Add("class");
  2663.             s_structString = newTable.Add("struct");
  2664.             s_ISerializableString = newTable.Add("ISerializable");
  2665.             s_marshalByRefString = newTable.Add("MarshalByRefObject");
  2666.             s_delegateString = newTable.Add("Delegate");
  2667.             s_servicedComponentString = newTable.Add("ServicedComponent");
  2668.             s_comObjectString = newTable.Add("__ComObject");
  2669.             s_portString = newTable.Add("port");
  2670.             s_styleString = newTable.Add("style");
  2671.             s_transportString = newTable.Add("transport");
  2672.             s_encodedString = newTable.Add("encoded");
  2673.             s_faultString = newTable.Add("fault");
  2674.             s_bodyString = newTable.Add("body");
  2675.             s_partsString = newTable.Add("parts");
  2676.             s_headerString = newTable.Add("header");
  2677.             s_encodingStyleString = newTable.Add("encodingStyle");
  2678.             s_restrictionString = newTable.Add("restriction");
  2679.             s_complexContentString = newTable.Add("complexContent");
  2680.             s_soapEncodingString = newTable.Add("http://schemas.xmlsoap.org/soap/encoding/");
  2681.             s_arrayTypeString = newTable.Add("arrayType");
  2682.             s_parameterOrderString = newTable.Add("parameterOrder");
  2683.            
  2684.            
  2685.             return ((XmlNameTable)newTable);
  2686.            
  2687.             // Enqueue a timer if it has not already been done
  2688.             /*Timer timer = new Timer(new TimerCallback(Cleanup), null, 1000, 1000);
  2689.             Object existingTimer = Interlocked.CompareExchange(ref s_enqueuedTimer, timer, null);
  2690.             if(existingTimer != null)
  2691.             timer.Dispose(); */           
  2692.             //}
  2693.            
  2694.             //return((XmlNameTable) s_atomizedTable);
  2695.         }
  2696.        
  2697.         // Private fields
  2698.         private XmlTextReader _XMLReader;
  2699.         private ArrayList _URTNamespaces;
  2700.         private ReaderStream _parsingInput;
  2701.         internal bool _bWrappedProxy;
  2702.         private string _proxyNamespace;
  2703.         private int _proxyNamespaceCount = 0;
  2704.         private ReaderStream _readerStreamsWsdl;
  2705.         private ReaderStream _readerStreamsXsd;
  2706.         private string _outputDir;
  2707.         private ArrayList _outCodeStreamList;
  2708.         private WriterStream _writerStreams;
  2709.         private SchemaBlockType _blockDefault;
  2710.         private XsdVersion _xsdVersion;
  2711.         private Hashtable wsdlMessages = new Hashtable(10);
  2712.         private Hashtable wsdlPortTypes = new Hashtable(10);
  2713.         private ArrayList wsdlBindings = new ArrayList(10);
  2714.         private ArrayList wsdlServices = new ArrayList(10);
  2715.         private Stack _currentReaderStack = new Stack(5);
  2716.         private Stack _currentSchemaReaderStack = new Stack(5);
  2717.         private XmlNameTable _primedNametable = null;
  2718.        
  2719.        
  2720.         //static private Object s_atomizedTable = null;
  2721.         //static private int s_counter = 0;
  2722.         //static private Object s_enqueuedTimer = null;
  2723.         private static string s_emptyString;
  2724.         private static string s_complexTypeString;
  2725.         private static string s_simpleTypeString;
  2726.         private static string s_elementString;
  2727.         private static string s_enumerationString;
  2728.         private static string s_encodingString;
  2729.         private static string s_attributeString;
  2730.         private static string s_attributesString;
  2731.         private static string s_allString;
  2732.         private static string s_sequenceString;
  2733.         private static string s_choiceString;
  2734.         private static string s_minOccursString;
  2735.         private static string s_maxOccursString;
  2736.         private static string s_unboundedString;
  2737.         private static string s_oneString;
  2738.         private static string s_zeroString;
  2739.         private static string s_nameString;
  2740.         private static string s_enumTypeString;
  2741.         private static string s_typeString;
  2742.         private static string s_baseString;
  2743.         private static string s_valueString;
  2744.         private static string s_interfaceString;
  2745.         private static string s_serviceString;
  2746.         private static string s_extendsString;
  2747.         private static string s_addressesString;
  2748.         private static string s_addressString;
  2749.         private static string s_uriString;
  2750.         private static string s_implementsString;
  2751.         private static string s_nestedTypeString;
  2752.         private static string s_requestString;
  2753.         private static string s_responseString;
  2754.         private static string s_requestResponseString;
  2755.         private static string s_messageString;
  2756.         private static string s_locationString;
  2757.         private static string s_schemaLocationString;
  2758.         private static string s_importString;
  2759.         private static string s_includeString;
  2760.         private static string s_onewayString;
  2761.         private static string s_refString;
  2762.         private static string s_refTypeString;
  2763.         private static string s_referenceString;
  2764.         private static string s_arrayString;
  2765.         private static string s_objectString;
  2766.         private static string s_urTypeString;
  2767.         private static string s_methodString;
  2768.         private static string s_sudsString;
  2769.         private static string s_useString;
  2770.         private static string s_rootTypeString;
  2771.         private static string s_soapString;
  2772.         private static string s_serviceDescString;
  2773.         private static string s_schemaString;
  2774.         private static string s_targetNamespaceString;
  2775.         private static string s_namespaceString;
  2776.         private static string s_idString;
  2777.         private static string s_soapActionString;
  2778.         private static string s_instanceNamespaceString;
  2779.         private static string s_schemaNamespaceString;
  2780.         private static string s_instanceNamespaceString1999;
  2781.         private static string s_schemaNamespaceString1999;
  2782.         private static string s_instanceNamespaceString2000;
  2783.         private static string s_schemaNamespaceString2000;
  2784.         private static string s_soapNamespaceString;
  2785.         private static string s_sudsNamespaceString;
  2786.         private static string s_serviceNamespaceString;
  2787.        
  2788.         //Wsdl
  2789.         private static string s_definitionsString;
  2790.         private static string s_wsdlNamespaceString;
  2791.         private static string s_wsdlSoapNamespaceString;
  2792.         private static string s_wsdlSudsNamespaceString;
  2793.         private static string s_typesString;
  2794.         private static string s_partString;
  2795.         private static string s_portTypeString;
  2796.         private static string s_operationString;
  2797.         private static string s_inputString;
  2798.         private static string s_outputString;
  2799.         private static string s_bindingString;
  2800.         private static string s_classString;
  2801.         private static string s_structString;
  2802.         private static string s_ISerializableString;
  2803.         private static string s_marshalByRefString;
  2804.         private static string s_delegateString;
  2805.         private static string s_servicedComponentString;
  2806.         private static string s_comObjectString;
  2807.         private static string s_portString;
  2808.         private static string s_styleString;
  2809.         private static string s_transportString;
  2810.         private static string s_encodedString;
  2811.         private static string s_faultString;
  2812.         private static string s_bodyString;
  2813.         private static string s_partsString;
  2814.         private static string s_headerString;
  2815.         private static string s_encodingStyleString;
  2816.         private static string s_restrictionString;
  2817.         private static string s_complexContentString;
  2818.         private static string s_soapEncodingString;
  2819.         private static string s_arrayTypeString;
  2820.         private static string s_parameterOrderString;
  2821.        
  2822.        
  2823.        
  2824. /***************************************************************
  2825.         **
  2826.         ** Private classes used by SUDS Parser
  2827.         **
  2828.         ***************************************************************/       
  2829.         // Input streams
  2830.         internal class ReaderStream
  2831.         {
  2832.             internal ReaderStream(string location)
  2833.             {
  2834.                 Util.Log("ReaderStream.ReaderStream " + location);
  2835.                 _location = location;
  2836.                 _name = String.Empty;
  2837.                 _targetNS = String.Empty;
  2838.                 _uniqueNS = null;
  2839.                 _reader = null;
  2840.                 _next = null;
  2841.             }
  2842.             internal string Location {
  2843.                 get { return (_location); }
  2844.                 set { _location = value; }
  2845.             }
  2846.             internal string Name {
  2847.                 set { _name = value; }
  2848.             }
  2849.             internal string TargetNS {
  2850.                 get { return (_targetNS); }
  2851.                 set { _targetNS = value; }
  2852.             }
  2853.             internal URTNamespace UniqueNS {
  2854.                 get { return (_uniqueNS); }
  2855.                 set { _uniqueNS = value; }
  2856.             }
  2857.             internal TextReader InputStream {
  2858.                 get { return (_reader); }
  2859.                 set { _reader = value; }
  2860.             }
  2861.             internal Uri Uri {
  2862.                 get { return (_uri); }
  2863.                 set { _uri = value; }
  2864.             }
  2865.            
  2866.             static internal void GetReaderStream(ReaderStream inputStreams, ReaderStream newStream)
  2867.             {
  2868.                 Util.Log("ReaderStream.GetReaderStream " + newStream.Location);
  2869.                 ReaderStream input = inputStreams;
  2870.                 ReaderStream last;
  2871.                 do {
  2872.                     Util.Log("ReaderStream.GetReaderStream location match input.location " + input._location + " location " + newStream.Location);
  2873.                     if (input._location == newStream.Location)
  2874.                         return;
  2875.                     last = input;
  2876.                     input = input._next;
  2877.                 }
  2878.                 while (input != null);
  2879.                
  2880.                 input = newStream;
  2881.                 last._next = input;
  2882.                
  2883.                 return;
  2884.             }
  2885.             static internal ReaderStream GetNextReaderStream(ReaderStream input)
  2886.             {
  2887.                 Util.Log("ReaderStream.GetNextReaderStream " + input._next);
  2888.                 return input._next;
  2889.             }
  2890.            
  2891.             private string _location;
  2892.             private string _name;
  2893.             private string _targetNS;
  2894.             private URTNamespace _uniqueNS;
  2895.             private TextReader _reader;
  2896.             private ReaderStream _next;
  2897.             private Uri _uri;
  2898.         }
  2899.        
  2900.         internal class WriterStream
  2901.         {
  2902.            
  2903.             private WriterStream(string fileName, TextWriter writer)
  2904.             {
  2905.                 Util.Log("WriterStream.WriterStream " + fileName);
  2906.                 _fileName = fileName;
  2907.                 _writer = writer;
  2908.             }
  2909.             internal TextWriter OutputStream {
  2910.                 get { return (_writer); }
  2911.             }
  2912.            
  2913.             internal bool GetWrittenTo()
  2914.             {
  2915.                 return _bWrittenTo;
  2916.                
  2917.             }
  2918.            
  2919.             internal void SetWrittenTo()
  2920.             {
  2921.                 _bWrittenTo = true;
  2922.             }
  2923.            
  2924.             static internal void Flush(WriterStream writerStream)
  2925.             {
  2926.                 while (writerStream != null) {
  2927.                     writerStream._writer.Flush();
  2928.                     writerStream = writerStream._next;
  2929.                 }
  2930.                
  2931.                 return;
  2932.             }
  2933.            
  2934.             static internal WriterStream GetWriterStream(ref WriterStream outputStreams, string outputDir, string fileName, ref string completeFileName)
  2935.             {
  2936.                 Util.Log("WriterStream.GetWriterStream " + fileName);
  2937.                 WriterStream output = outputStreams;
  2938.                 while (output != null) {
  2939.                     if (output._fileName == fileName)
  2940.                         return (output);
  2941.                     output = output._next;
  2942.                 }
  2943.                
  2944.                 string diskFileName = fileName;
  2945.                 if (diskFileName.EndsWith(".exe", StringComparison.Ordinal) || diskFileName.EndsWith(".dll", StringComparison.Ordinal))
  2946.                     diskFileName = diskFileName.Substring(0, diskFileName.Length - 4);
  2947.                 string _completeFileName = outputDir + diskFileName + ".cs";
  2948.                 completeFileName = _completeFileName;
  2949.                 //TextWriter textWriter = new StreamWriter(outputDir + fileName + ".cs", false);
  2950.                 TextWriter textWriter = new StreamWriter(_completeFileName, false, new UTF8Encoding(false));
  2951.                 output = new WriterStream(fileName, textWriter);
  2952.                 output._next = outputStreams;
  2953.                 outputStreams = output;
  2954.                 Util.Log("WriterStream.GetWriterStream in fileName " + fileName + " completeFileName " + _completeFileName);
  2955.                 return (output);
  2956.             }
  2957.            
  2958.             static internal void Close(WriterStream outputStreams)
  2959.             {
  2960.                 WriterStream output = outputStreams;
  2961.                 while (output != null) {
  2962.                     output._writer.Close();
  2963.                     output = output._next;
  2964.                 }
  2965.             }
  2966.            
  2967.             private string _fileName;
  2968.             private TextWriter _writer;
  2969.             private WriterStream _next;
  2970.             private bool _bWrittenTo = false;
  2971.         }
  2972.        
  2973.         // Represents a parameter of a method
  2974.         [Serializable()]
  2975.         internal enum URTParamType
  2976.         {
  2977.             IN,
  2978.             OUT,
  2979.             REF
  2980.         }
  2981.         internal class URTParam
  2982.         {
  2983.             internal URTParam(string name, string typeName, string typeNS, string encodedNS, URTParamType pType, bool bEmbedded, WsdlParser parser, URTNamespace urtNamespace)
  2984.             {
  2985.                 Util.Log("URTParam.URTParam name " + name + " typeName " + typeName + " typeNS " + typeNS + " ecodedNS " + encodedNS + " pType " + pType + " bEmbedded " + bEmbedded);
  2986.                 _name = name;
  2987.                 _typeName = typeName;
  2988.                 _typeNS = typeNS;
  2989.                 _encodedNS = encodedNS;
  2990.                 _pType = pType;
  2991.                 _embeddedParam = bEmbedded;
  2992.                 _parser = parser;
  2993.                 _urtNamespace = urtNamespace;
  2994.                
  2995.             }
  2996.             public override bool Equals(object obj)
  2997.             {
  2998.                 //Util.Log("URTParam.Equals ");
  2999.                 URTParam suppliedParam = (URTParam)obj;
  3000.                 if (_pType == suppliedParam._pType && WsdlParser.MatchingStrings(_typeName, suppliedParam._typeName) && WsdlParser.MatchingStrings(_typeNS, suppliedParam._typeNS))
  3001.                     return (true);
  3002.                
  3003.                 return (false);
  3004.             }
  3005.            
  3006.            
  3007.             public override int GetHashCode()
  3008.             {
  3009.                 return base.GetHashCode();
  3010.             }
  3011.             internal URTParamType ParamType {
  3012.                 get { return (_pType); }
  3013.                 set { _pType = value; }
  3014.             }
  3015.             internal string Name {
  3016.                 get { return (_name); }
  3017.             }
  3018.             internal string TypeName {
  3019.                 get { return (_typeName); }
  3020.             }
  3021.             internal string TypeNS {
  3022.                 get { return (_typeNS); }
  3023.             }
  3024.            
  3025.             internal string GetTypeString(string curNS, bool bNS)
  3026.             {
  3027.                 return _parser.GetTypeString(curNS, bNS, _urtNamespace, _typeName, _encodedNS);
  3028.             }
  3029.            
  3030.             internal void PrintCSC(StringBuilder sb, string curNS)
  3031.             {
  3032.                 Util.Log("URTParam.PrintCSC curNS " + curNS + " name " + _name);
  3033.                 //if(_embeddedParam)
  3034.                 // sb.Append("[Embedded] ");
  3035.                 sb.Append(PTypeString[(int)_pType]);
  3036.                 sb.Append(GetTypeString(curNS, true));
  3037.                 sb.Append(' ');
  3038.                 sb.Append(WsdlParser.IsValidCS(_name));
  3039.                 return;
  3040.             }
  3041.             internal void PrintCSC(StringBuilder sb)
  3042.             {
  3043.                 Util.Log("URTParam.PrintCSC name " + _name);
  3044.                 sb.Append(PTypeString[(int)_pType]);
  3045.                 sb.Append(WsdlParser.IsValidCS(_name));
  3046.                 return;
  3047.             }
  3048.            
  3049.             private static string[] PTypeString = {"", "out ", "ref "};
  3050.             private string _name;
  3051.             private string _typeName;
  3052.             private string _typeNS;
  3053.             private string _encodedNS;
  3054.             private URTParamType _pType;
  3055.             private bool _embeddedParam;
  3056.             private URTNamespace _urtNamespace;
  3057.             private WsdlParser _parser;
  3058.         }
  3059.        
  3060.         [Flags()]
  3061.         internal enum MethodPrintEnum
  3062.         {
  3063.             PrintBody = 1,
  3064.             InterfaceMethods = 2,
  3065.             InterfaceInClass = 4
  3066.         }
  3067.        
  3068.         [Flags()]
  3069.         internal enum MethodFlags
  3070.         {
  3071.             None = 0,
  3072.             Public = 1,
  3073.             Protected = 2,
  3074.             Override = 4,
  3075.             New = 8,
  3076.             Virtual = 16,
  3077.             Internal = 32
  3078.         }
  3079.        
  3080.        
  3081.         // Represents a method
  3082.         internal abstract class URTMethod
  3083.         {
  3084.            
  3085.             static internal bool FlagTest(MethodPrintEnum flag, MethodPrintEnum target)
  3086.             {
  3087.                 if ((flag & target) == target)
  3088.                     return true;
  3089.                 else
  3090.                     return false;
  3091.             }
  3092.            
  3093.             static internal bool MethodFlagsTest(MethodFlags flag, MethodFlags target)
  3094.             {
  3095.                 if ((flag & target) == target)
  3096.                     return true;
  3097.                 else
  3098.                     return false;
  3099.             }
  3100.            
  3101.             internal URTMethod(string name, string soapAction, string methodAttributes, URTComplexType complexType)
  3102.             {
  3103.                 Util.Log("URTMethod.URTMethod name " + name + " soapAction " + soapAction + " attributes " + methodAttributes + " complexType " + complexType);
  3104.                 _methodName = name;
  3105.                 _soapAction = soapAction;
  3106.                 _methodType = null;
  3107.                 _complexType = complexType;
  3108.                 int index = name.IndexOf('.');
  3109.                 _methodFlags = MethodFlags.None;
  3110.                
  3111.                 // set method flags
  3112.                 if (methodAttributes != null && methodAttributes.Length > 0) {
  3113.                     string[] attributes = methodAttributes.Split(' ');
  3114.                     foreach (string attribute in attributes) {
  3115.                         if (attribute == "virtual")
  3116.                             _methodFlags |= MethodFlags.Virtual;
  3117.                         if (attribute == "new")
  3118.                             _methodFlags |= MethodFlags.New;
  3119.                         if (attribute == "override")
  3120.                             _methodFlags |= MethodFlags.Override;
  3121.                         if (attribute == "public")
  3122.                             _methodFlags |= MethodFlags.Public;
  3123.                         if (attribute == "protected")
  3124.                             _methodFlags |= MethodFlags.Protected;
  3125.                         if (attribute == "internal")
  3126.                             _methodFlags |= MethodFlags.Internal;
  3127.                     }
  3128.                 }
  3129.                
  3130.                 Util.Log("URTMethod.URTMethod methodFlags " + ((Enum)_methodFlags).ToString());
  3131.             }
  3132.            
  3133.            
  3134.             internal string Name {
  3135.                 get { return (_methodName); }
  3136.             }
  3137.            
  3138.             internal string SoapAction {
  3139.                 get { return (_soapAction); }
  3140.             }
  3141.             internal MethodFlags MethodFlags {
  3142.                 get { return (_methodFlags); }
  3143.                 set { _methodFlags = value; }
  3144.             }
  3145.            
  3146.             internal string GetTypeString(string curNS, bool bNS)
  3147.             {
  3148.                 Util.Log("URTMethod.GetTypeString curNS " + curNS + " bNS " + bNS);
  3149.                 return ((_methodType != null) ? _methodType.GetTypeString(curNS, bNS) : "void");
  3150.             }
  3151.             protected URTParam MethodType {
  3152.                 get { return (_methodType); }
  3153.             }
  3154.             public override int GetHashCode()
  3155.             {
  3156.                 return base.GetHashCode();
  3157.             }
  3158.             public override bool Equals(object obj)
  3159.             {
  3160.                 URTMethod suppliedMethod = (URTMethod)obj;
  3161.                 if (WsdlParser.MatchingStrings(_methodName, suppliedMethod._methodName) && _params.Count == suppliedMethod._params.Count) {
  3162.                     for (int i = 0; i < _params.Count; i++) {
  3163.                         if (_params[i].Equals(suppliedMethod._params[i]) == false)
  3164.                             return (false);
  3165.                     }
  3166.                    
  3167.                     return (true);
  3168.                 }
  3169.                
  3170.                 return (false);
  3171.             }
  3172.             internal MethodFlags GetMethodFlags(MethodInfo method)
  3173.             {
  3174.                 return (_methodFlags);
  3175.             }
  3176.            
  3177.             internal void AddParam(URTParam newParam)
  3178.             {
  3179.                 Util.Log("URTMethod.AddParam " + newParam.Name);
  3180.                 for (int i = 0; i < _params.Count; i++) {
  3181.                     URTParam extParam = (URTParam)_params[i];
  3182.                     if (WsdlParser.MatchingStrings(extParam.Name, newParam.Name)) {
  3183.                         if (extParam.ParamType == URTParamType.IN && newParam.ParamType == URTParamType.OUT && WsdlParser.MatchingStrings(extParam.TypeName, newParam.TypeName) && WsdlParser.MatchingStrings(extParam.TypeNS, newParam.TypeNS)) {
  3184.                             extParam.ParamType = URTParamType.REF;
  3185.                             return;
  3186.                         }
  3187.                        
  3188.                         throw new SUDSParserException(CoreChannel.GetResourceString("Remoting_Suds_DuplicateParameter"));
  3189.                     }
  3190.                 }
  3191.                
  3192.                 // Find parameter position
  3193.                 int paramPosition = -1;
  3194.                 if (_paramNamesOrder != null) {
  3195.                     // Parameter order find the parameter position or determine if the parameter is a return value
  3196.                     for (int i = 0; i < _paramNamesOrder.Length; i++) {
  3197.                         if (_paramNamesOrder[i] == newParam.Name) {
  3198.                             paramPosition = i;
  3199.                             break;
  3200.                         }
  3201.                     }
  3202.                    
  3203.                     if (paramPosition == -1) {
  3204.                         // return value
  3205.                         _methodType = newParam;
  3206.                     }
  3207.                     else {
  3208.                         // Parameter, add the correct position
  3209.                         //_params[paramPosition] = newParam; // _params array list is the size of the parameters.
  3210.                         _params.Add(newParam);
  3211.                         _paramPosition.Add(paramPosition);
  3212.                     }
  3213.                 }
  3214.                 else {
  3215.                     // no parameterOrder in wsdl, do the best we can to determine if there is a return value
  3216.                     if ((_methodType == null) && (newParam.ParamType == URTParamType.OUT)) {
  3217.                         // return value
  3218.                         _methodType = newParam;
  3219.                     }
  3220.                     else {
  3221.                         // parameter put as the next parameter
  3222.                         _params.Add(newParam);
  3223.                     }
  3224.                 }
  3225.             }
  3226.            
  3227.             internal void ResolveMethodAttributes()
  3228.             {
  3229.                 Util.Log("URTMethod.ResolveMethodAttributes " + Name + " MethodFlags " + ((Enum)_methodFlags).ToString());
  3230.                 if (!(MethodFlagsTest(_methodFlags, MethodFlags.Override) || MethodFlagsTest(_methodFlags, MethodFlags.New)))
  3231.                     FindMethodAttributes();
  3232.             }
  3233.            
  3234.             private void FindMethodAttributes()
  3235.             {
  3236.                 Util.Log("URTMethod.FindMethodAttributes " + Name + " complexType " + _complexType);
  3237.                 if (_complexType == null)
  3238.                     return;
  3239.                
  3240.                 Util.Log("URTMethod.FindMethodAttributes " + _complexType.Name);
  3241.                
  3242.                 ArrayList inherit = _complexType.Inherit;
  3243.                 Type baseType = null;
  3244.                 if (inherit == null) {
  3245.                     inherit = new ArrayList();
  3246.                     if (_complexType.SUDSType == SUDSType.ClientProxy)
  3247.                         baseType = typeof(System.Runtime.Remoting.Services.RemotingClientProxy);
  3248.                     else if (_complexType.SudsUse == SudsUse.MarshalByRef)
  3249.                         baseType = typeof(MarshalByRefObject);
  3250.                     else if (_complexType.SudsUse == SudsUse.ServicedComponent)
  3251.                         baseType = typeof(MarshalByRefObject);
  3252.                    
  3253.                     if (baseType == null)
  3254.                         return;
  3255.                    
  3256.                     while (baseType != null) {
  3257.                         Util.Log("URTMethod.FindMethodAttributes baseType Enter " + baseType);
  3258.                         inherit.Add(baseType);
  3259.                         baseType = baseType.BaseType;
  3260.                     }
  3261.                    
  3262.                     _complexType.Inherit = inherit;
  3263.                 }
  3264.                
  3265.                 BindingFlags bFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
  3266.                
  3267.                 bool bVirtual = MethodFlagsTest(_methodFlags, MethodFlags.Virtual);
  3268.                 Util.Log("URTMethod.FindMethodAttributes " + Name + " bVirtual " + bVirtual);
  3269.                
  3270.                 // See if method hides inherited methods
  3271.                 bool bfound = false;
  3272.                 for (int j = 0; j < inherit.Count; j++) {
  3273.                     baseType = (Type)inherit[j];
  3274.                     MethodInfo[] baseInfos = null;
  3275.                     try {
  3276.                         MethodInfo methodInfo = baseType.GetMethod(Name, bFlags);
  3277.                         if (methodInfo != null) {
  3278.                             baseInfos = new MethodInfo[1];
  3279.                             baseInfos[0] = methodInfo;
  3280.                         }
  3281.                     }
  3282.                     catch {
  3283.                         // Ambiguous match, overloaded methos
  3284.                         baseInfos = baseType.GetMethods(bFlags);
  3285.                     }
  3286.                    
  3287.                     if (baseInfos != null) {
  3288.                         foreach (MethodBase baseInfo in baseInfos) {
  3289.                             if (baseInfo != null && baseInfo.Name == Name && (baseInfo.IsFamily || baseInfo.IsPublic || baseInfo.IsAssembly) && IsSignature(baseInfo)) {
  3290.                                 bfound = true;
  3291.                                
  3292.                                 // Change attribute to match new hiearchy
  3293.                                 if (!baseInfo.IsPublic) {
  3294.                                     if (baseInfo.IsAssembly) {
  3295.                                         _methodFlags &= ~(MethodFlags.Public);
  3296.                                         _methodFlags |= MethodFlags.Internal;
  3297.                                     }
  3298.                                     else if (baseInfo.IsFamily) {
  3299.                                         _methodFlags &= ~(MethodFlags.Public);
  3300.                                         _methodFlags |= MethodFlags.Protected;
  3301.                                     }
  3302.                                 }
  3303.                                
  3304.                                 // Hides
  3305.                                 if (baseInfo.IsFinal)
  3306.                                     _methodFlags |= MethodFlags.New;
  3307.                                 else if (baseInfo.IsVirtual && bVirtual)
  3308.                                     _methodFlags |= MethodFlags.Override;
  3309.                                 else
  3310.                                     _methodFlags |= MethodFlags.New;
  3311.                                 break;
  3312.                             }
  3313.                         }
  3314.                     }
  3315.                     if (bfound)
  3316.                         break;
  3317.                 }
  3318.                
  3319.                 Util.Log("URTMethod.FindMethodAttributes Exit " + Name + " " + ((Enum)_methodFlags).ToString());
  3320.             }
  3321.            
  3322.             private bool IsSignature(MethodBase baseInfo)
  3323.             {
  3324.                 ParameterInfo[] paramInfos = baseInfo.GetParameters();
  3325.                 Util.Log("URTMethod.IsSignature param length " + paramInfos.Length + " URTParams length " + _params.Count);
  3326.                
  3327.                 if (_params.Count != paramInfos.Length)
  3328.                     return false;
  3329.                
  3330.                 bool bsig = true;
  3331.                
  3332.                 for (int i = 0; i < paramInfos.Length; i++) {
  3333.                     URTParam param = (URTParam)_params[i];
  3334.                     if (param.GetTypeString(null, true) != paramInfos[i].ParameterType.FullName) {
  3335.                         bsig = false;
  3336.                         break;
  3337.                        
  3338.                     }
  3339.                 }
  3340.                
  3341.                 return bsig;
  3342.             }
  3343.            
  3344.             internal void PrintSignature(StringBuilder sb, string curNS)
  3345.             {
  3346.                 Util.Log("URTMethod.PrintSignature curNS " + curNS);
  3347.                 for (int i = 0; i < _params.Count; i++) {
  3348.                     if (i != 0)
  3349.                         sb.Append(", ");
  3350.                     Util.Log("URTMethod.PrintSignature Invoke _params PrintCSC");
  3351.                     ((URTParam)_params[i]).PrintCSC(sb, curNS);
  3352.                 }
  3353.                
  3354.                 return;
  3355.             }
  3356. /*
  3357.             internal abstract void PrintCSC(TextWriter textWriter, String indentation,
  3358.                                             String namePrefix, String curNS, MethodPrintEnum methodPrintEnum,
  3359.                                             bool bURTType, String bodyPrefix, StringBuilder sb);
  3360.                                             */           
  3361.            
  3362.             internal virtual void PrintCSC(TextWriter textWriter, string indentation, string namePrefix, string curNS, MethodPrintEnum methodPrintEnum, bool bURTType, string bodyPrefix, StringBuilder sb)
  3363.             {
  3364.                 Util.Log("URTMethod.PrintCSC name " + _methodName + " namePrefix " + namePrefix + " curNS " + curNS + " MethodPrintEnum " + ((Enum)methodPrintEnum).ToString());
  3365.                
  3366.                 // Check for class methods
  3367.                 sb.Length = 0;
  3368.                 sb.Append(indentation);
  3369.                
  3370.                 if (Name == "Finalize")
  3371.                     return;
  3372.                
  3373.                 if (FlagTest(methodPrintEnum, MethodPrintEnum.InterfaceInClass))
  3374.                     sb.Append("public ");
  3375.                 else if (MethodFlagsTest(_methodFlags, MethodFlags.Public))
  3376.                     sb.Append("public ");
  3377.                 else if (MethodFlagsTest(_methodFlags, MethodFlags.Protected))
  3378.                     sb.Append("protected ");
  3379.                 else if (MethodFlagsTest(_methodFlags, MethodFlags.Internal))
  3380.                     sb.Append("internal ");
  3381.                
  3382.                 if (MethodFlagsTest(_methodFlags, MethodFlags.Override))
  3383.                     sb.Append("override ");
  3384.                 else if (MethodFlagsTest(_methodFlags, MethodFlags.Virtual))
  3385.                    
  3386.                     sb.Append("virtual ");
  3387.                
  3388.                 if (MethodFlagsTest(_methodFlags, MethodFlags.New))
  3389.                     sb.Append("new ");
  3390.                
  3391.                 sb.Append(WsdlParser.IsValidCSAttr(GetTypeString(curNS, true)));
  3392.                
  3393.                 if (FlagTest(methodPrintEnum, MethodPrintEnum.InterfaceInClass))
  3394.                     sb.Append(" ");
  3395.                 else
  3396.                     sb.Append(WsdlParser.IsValidCSAttr(namePrefix));
  3397.                 if (_wsdlMethodInfo.bProperty)
  3398.                     sb.Append(WsdlParser.IsValidCS(_wsdlMethodInfo.propertyName));
  3399.                 else {
  3400.                     sb.Append(WsdlParser.IsValidCS(_methodName));
  3401.                    
  3402.                     sb.Append('(');
  3403.                     if (_params.Count > 0) {
  3404.                         Util.Log("URTMethod.PrintCSC Invoke _params[0] 1 PrintCSC");
  3405.                         ((URTParam)_params[0]).PrintCSC(sb, curNS);
  3406.                         for (int i = 1; i < _params.Count; i++) {
  3407.                             sb.Append(", ");
  3408.                             Util.Log("URTMethod.PrintCSC Invoke _params 2 PrintCSC " + i);
  3409.                             ((URTParam)_params[i]).PrintCSC(sb, curNS);
  3410.                         }
  3411.                     }
  3412.                     sb.Append(')');
  3413.                 }
  3414.                
  3415.                 if (_wsdlMethodInfo.bProperty && FlagTest(methodPrintEnum, MethodPrintEnum.InterfaceMethods)) {
  3416.                     sb.Append("{");
  3417.                     if (_wsdlMethodInfo.bGet)
  3418.                         sb.Append(" get; ");
  3419.                     if (_wsdlMethodInfo.bSet)
  3420.                         sb.Append(" set; ");
  3421.                     sb.Append("}");
  3422.                 }
  3423.                 else if (!FlagTest(methodPrintEnum, MethodPrintEnum.PrintBody))
  3424.                     sb.Append(';');
  3425.                
  3426.                 textWriter.WriteLine(sb);
  3427.                
  3428.                 if (_wsdlMethodInfo.bProperty && FlagTest(methodPrintEnum, MethodPrintEnum.PrintBody))
  3429.                     PrintPropertyBody(textWriter, indentation, sb, bodyPrefix);
  3430.                
  3431.                 else if (FlagTest(methodPrintEnum, MethodPrintEnum.PrintBody)) {
  3432.                     sb.Length = 0;
  3433.                     sb.Append(indentation);
  3434.                     sb.Append('{');
  3435.                     textWriter.WriteLine(sb);
  3436.                    
  3437.                     string newIndentation = indentation + " ";
  3438.                     if (bodyPrefix == null) {
  3439.                         for (int i = 0; i < _params.Count; i++) {
  3440.                             URTParam param = (URTParam)_params[i];
  3441.                             if (param.ParamType == URTParamType.OUT) {
  3442.                                 sb.Length = 0;
  3443.                                 sb.Append(newIndentation);
  3444.                                 sb.Append(WsdlParser.IsValidCS(param.Name));
  3445.                                 sb.Append(" = ");
  3446.                                 sb.Append(ValueString(param.GetTypeString(curNS, true)));
  3447.                                 sb.Append(';');
  3448.                                 textWriter.WriteLine(sb);
  3449.                             }
  3450.                         }
  3451.                         Util.Log("URTMethod.PrintCSC return print");
  3452.                         sb.Length = 0;
  3453.                         sb.Append(newIndentation);
  3454.                         sb.Append("return");
  3455.                         string returnString = ValueString(GetTypeString(curNS, true));
  3456.                         if (returnString != null) {
  3457.                             sb.Append('(');
  3458.                             sb.Append(returnString);
  3459.                             sb.Append(')');
  3460.                         }
  3461.                         sb.Append(';');
  3462.                     }
  3463.                     else {
  3464.                         sb.Length = 0;
  3465.                         sb.Append(newIndentation);
  3466.                         if (ValueString(GetTypeString(curNS, true)) != null)
  3467.                             sb.Append("return ");
  3468.                         PrintMethodName(sb, bodyPrefix, _methodName);
  3469.                         //sb.Append(bodyPrefix);
  3470.                         //sb.Append(_methodName);
  3471.                         sb.Append('(');
  3472.                         if (_params.Count > 0) {
  3473.                             Util.Log("URTMethod.PrintCSC Invoke _params[0] 3 PrintCSC");
  3474.                             ((URTParam)_params[0]).PrintCSC(sb);
  3475.                             for (int i = 1; i < _params.Count; i++) {
  3476.                                 sb.Append(", ");
  3477.                                 Util.Log("URTMethod.PrintCSC Invoke _params 4 PrintCSC");
  3478.                                 ((URTParam)_params[i]).PrintCSC(sb);
  3479.                             }
  3480.                         }
  3481.                         sb.Append(");");
  3482.                     }
  3483.                     textWriter.WriteLine(sb);
  3484.                    
  3485.                     textWriter.Write(indentation);
  3486.                     textWriter.WriteLine('}');
  3487.                 }
  3488.             }
  3489.            
  3490.             private void PrintSoapAction(string action, StringBuilder sb)
  3491.             {
  3492.                 sb.Append("[SoapMethod(SoapAction=");
  3493.                 sb.Append(WsdlParser.IsValidUrl(action));
  3494.                 sb.Append(")]");
  3495.             }
  3496.            
  3497.             private void PrintPropertyBody(TextWriter textWriter, string indentation, StringBuilder sb, string bodyPrefix)
  3498.             {
  3499.                
  3500.                 sb.Length = 0;
  3501.                 sb.Append(indentation);
  3502.                 sb.Append('{');
  3503.                 textWriter.WriteLine(sb);
  3504.                
  3505.                 string newIndentation = indentation + " ";
  3506.                 sb.Length = 0;
  3507.                 sb.Append(newIndentation);
  3508.                 if (_wsdlMethodInfo.bGet) {
  3509.                     sb.Length = 0;
  3510.                     sb.Append(newIndentation);
  3511.                     PrintSoapAction(_wsdlMethodInfo.soapActionGet, sb);
  3512.                     textWriter.WriteLine(sb);
  3513.                    
  3514.                     sb.Length = 0;
  3515.                     sb.Append(newIndentation);
  3516.                     sb.Append("get{return ");
  3517.                     PrintMethodName(sb, bodyPrefix, _wsdlMethodInfo.propertyName);
  3518.                     //sb.Append(bodyPrefix);
  3519.                     //sb.Append(_wsdlMethodInfo.propertyName);
  3520.                     sb.Append(";}");
  3521.                     textWriter.WriteLine(sb);
  3522.                 }
  3523.                
  3524.                 if (_wsdlMethodInfo.bSet) {
  3525.                     if (_wsdlMethodInfo.bGet)
  3526.                         textWriter.WriteLine();
  3527.                    
  3528.                     sb.Length = 0;
  3529.                     sb.Append(newIndentation);
  3530.                     PrintSoapAction(_wsdlMethodInfo.soapActionSet, sb);
  3531.                     textWriter.WriteLine(sb);
  3532.                    
  3533.                     sb.Length = 0;
  3534.                     sb.Append(newIndentation);
  3535.                     sb.Append("set{");
  3536.                     PrintMethodName(sb, bodyPrefix, _wsdlMethodInfo.propertyName);
  3537.                     //sb.Append(bodyPrefix);
  3538.                     //sb.Append(_wsdlMethodInfo.propertyName);
  3539.                     sb.Append("= value;}");
  3540.                     textWriter.WriteLine(sb);
  3541.                 }
  3542.                
  3543.                 sb.Length = 0;
  3544.                 sb.Append(indentation);
  3545.                 sb.Append('}');
  3546.                 textWriter.WriteLine(sb);
  3547.             }
  3548.            
  3549.             private void PrintMethodName(StringBuilder sb, string bodyPrefix, string name)
  3550.             {
  3551.                 int index = name.LastIndexOf('.');
  3552.                 if (index < 0) {
  3553.                     sb.Append(bodyPrefix);
  3554.                     sb.Append(WsdlParser.IsValidCS(name));
  3555.                 }
  3556.                 else {
  3557.                     // interface name, need to reconstruct bodyPrefix and strip name qualifier
  3558.                     string iface = name.Substring(0, index);
  3559.                     string methodName = name.Substring(index + 1);
  3560.                     if (bodyPrefix == null) {
  3561.                         // Non-wrapped proxy
  3562.                         sb.Append("(");
  3563.                         sb.Append(WsdlParser.IsValidCS(iface));
  3564.                         sb.Append(")");
  3565.                         sb.Append(WsdlParser.IsValidCS(methodName));
  3566.                     }
  3567.                     else {
  3568.                         // wrapped proxy
  3569.                         sb.Append("((");
  3570.                         sb.Append(WsdlParser.IsValidCS(iface));
  3571.                         sb.Append(") _tp).");
  3572.                         sb.Append(WsdlParser.IsValidCS(methodName));
  3573.                     }
  3574.                 }
  3575.             }
  3576.            
  3577.             // Returns string that is appropriate for the return type
  3578.             static internal string ValueString(string paramType)
  3579.             {
  3580.                 string valueString;
  3581.                 if (paramType == "void")
  3582.                     valueString = null;
  3583.                 else if (paramType == "bool")
  3584.                     valueString = "false";
  3585.                 else if (paramType == "string")
  3586.                     valueString = "null";
  3587.                 else if (paramType == "sbyte" || paramType == "byte" || paramType == "short" || paramType == "ushort" || paramType == "int" || paramType == "uint" || paramType == "long" || paramType == "ulong")
  3588.                     valueString = "1";
  3589.                 else if (paramType == "float" || paramType == "exfloat")
  3590.                     valueString = "(float)1.0";
  3591.                 else if (paramType == "double" || paramType == "exdouble")
  3592.                     valueString = "1.0";
  3593.                 else {
  3594.                     StringBuilder sb = new StringBuilder(50);
  3595.                     sb.Append('(');
  3596.                     sb.Append(WsdlParser.IsValidCS(paramType));
  3597.                     sb.Append(") (Object) null");
  3598.                     valueString = sb.ToString();
  3599.                 }
  3600.                 Util.Log("URTMethod.ValueString paramType " + paramType + " valueString " + valueString);
  3601.                 return (valueString);
  3602.             }
  3603.            
  3604.             // This method is called when the parsing is complete
  3605.             // and is useful for derived types
  3606.             internal abstract void ResolveTypes(WsdlParser parser);
  3607.            
  3608.            
  3609.             // Helper method used by Resolve
  3610.             protected void ResolveWsdlParams(WsdlParser parser, string targetNS, string targetName, bool bRequest, WsdlMethodInfo wsdlMethodInfo)
  3611.             {
  3612.                 Util.Log("URTMethod.ResolveWsdlParams targetName " + targetName + " targetNS " + targetNS + " bRequest " + bRequest + " wsdlMethodInfo " + wsdlMethodInfo);
  3613.                 _wsdlMethodInfo = wsdlMethodInfo;
  3614.                 _paramNamesOrder = _wsdlMethodInfo.paramNamesOrder;
  3615.                
  3616.                 int length;
  3617.                 if (_wsdlMethodInfo.bProperty)
  3618.                     length = 1;
  3619.                 else if (bRequest)
  3620.                     length = wsdlMethodInfo.inputNames.Length;
  3621.                 else
  3622.                     length = wsdlMethodInfo.outputNames.Length;
  3623.                
  3624.                 for (int i = 0; i < length; i++) {
  3625.                     string element = null;
  3626.                     string elementNs = null;
  3627.                     string name = null;
  3628.                     string nameNs = null;
  3629.                     string typeName = null;
  3630.                     ;
  3631.                     string typeNameNs = null;
  3632.                     ;
  3633.                     URTParamType pType;
  3634.                     if (_wsdlMethodInfo.bProperty) {
  3635.                         typeName = wsdlMethodInfo.propertyType;
  3636.                         typeNameNs = wsdlMethodInfo.propertyNs;
  3637.                         pType = URTParamType.OUT;
  3638.                     }
  3639.                     else if (bRequest && !_wsdlMethodInfo.bProperty) {
  3640.                         element = wsdlMethodInfo.inputElements[i];
  3641.                         elementNs = wsdlMethodInfo.inputElementsNs[i];
  3642.                         name = wsdlMethodInfo.inputNames[i];
  3643.                         nameNs = wsdlMethodInfo.inputNamesNs[i];
  3644.                         typeName = wsdlMethodInfo.inputTypes[i];
  3645.                         typeNameNs = wsdlMethodInfo.inputTypesNs[i];
  3646.                        
  3647.                         pType = URTParamType.IN;
  3648.                     }
  3649.                     else {
  3650.                         element = wsdlMethodInfo.outputElements[i];
  3651.                         elementNs = wsdlMethodInfo.outputElementsNs[i];
  3652.                         name = wsdlMethodInfo.outputNames[i];
  3653.                         nameNs = wsdlMethodInfo.outputNamesNs[i];
  3654.                         typeName = wsdlMethodInfo.outputTypes[i];
  3655.                         typeNameNs = wsdlMethodInfo.outputTypesNs[i];
  3656.                         pType = URTParamType.OUT;
  3657.                     }
  3658.                    
  3659.                     string actualType;
  3660.                     string actualTypeNs;
  3661.                     if ((element == null) || element.Length == 0) {
  3662.                         actualType = typeName;
  3663.                         actualTypeNs = typeNameNs;
  3664.                     }
  3665.                     else {
  3666.                         actualType = element;
  3667.                         actualTypeNs = elementNs;
  3668.                     }
  3669.                    
  3670.                     Util.Log("URTMethod.ResolveWsdlParams actualType " + actualType + " actualTypeNs " + actualTypeNs);
  3671.                     URTNamespace ns = parser.LookupNamespace(actualTypeNs);
  3672.                     if (ns == null) {
  3673.                         throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), actualTypeNs, actualType));
  3674.                     }
  3675.                    
  3676.                     URTComplexType ct = ns.LookupComplexType(actualType);
  3677.                    
  3678.                     if (ct != null && ct.IsArray()) {
  3679.                         if (ct.GetArray() == null)
  3680.                             ct.ResolveArray();
  3681.                         string arrayName = ct.GetArray();
  3682.                         URTNamespace arrayNS = ct.GetArrayNS();
  3683.                         AddParam(new URTParam(name, arrayName, arrayNS.Name, arrayNS.EncodedNS, pType, true, parser, arrayNS));
  3684.                     }
  3685.                     else {
  3686.                         Util.Log("URTMethod.ResolveWsdlParams actualType 2 UrtType " + ((Enum)ns.UrtType).ToString());
  3687.                         if (ns.UrtType == UrtType.Xsd) {
  3688.                             string clrtypeName = parser.MapSchemaTypesToCSharpTypes(actualType);
  3689.                             AddParam(new URTParam(name, clrtypeName, ns.Namespace, ns.EncodedNS, pType, true, parser, ns));
  3690.                         }
  3691.                         else {
  3692.                             string foundTypeName = null;
  3693.                             if (ct != null) {
  3694.                                 foundTypeName = ct.Name;
  3695.                             }
  3696.                             else {
  3697.                                 URTSimpleType stype = ns.LookupSimpleType(actualType);
  3698.                                 if (stype != null) {
  3699.                                     foundTypeName = stype.Name;
  3700.                                 }
  3701.                                 else {
  3702.                                     foundTypeName = actualType;
  3703.                                    
  3704.                                     /*
  3705.                                     throw new SUDSParserException(
  3706.                                         String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"),
  3707.                                                       actualType, ns.Name));
  3708.                                                       */                                   
  3709.                                 }
  3710.                             }
  3711.                             //typeNS.RemoveComplexType(type);
  3712.                             AddParam(new URTParam(name, foundTypeName, ns.Namespace, ns.EncodedNS, pType, true, parser, ns));
  3713.                         }
  3714.                     }
  3715.                 }
  3716.             }
  3717.            
  3718.            
  3719.             // Fields
  3720.             private string _methodName;
  3721.             private string _soapAction;
  3722.             private URTParam _methodType;
  3723.             internal URTComplexType _complexType;
  3724.             protected string[] _paramNamesOrder;
  3725.             // parameterOrder names from wsdl
  3726.             protected ArrayList _params = new ArrayList();
  3727.             protected ArrayList _paramPosition = new ArrayList();
  3728.             private MethodFlags _methodFlags;
  3729.             private WsdlMethodInfo _wsdlMethodInfo;
  3730.         }
  3731.        
  3732.         // Repesents a request response method
  3733.         internal class RRMethod : URTMethod
  3734.         {
  3735.             // Constructor
  3736.            
  3737.             internal RRMethod(WsdlMethodInfo wsdlMethodInfo, URTComplexType complexType) : base(wsdlMethodInfo.methodName, wsdlMethodInfo.soapAction, wsdlMethodInfo.methodAttributes, complexType)
  3738.             {
  3739.                 Util.Log("RRMethod.RRMethod WsdlMethodInfo name " + wsdlMethodInfo.methodName + " soapAction " + wsdlMethodInfo.soapAction);
  3740.                 _wsdlMethodInfo = wsdlMethodInfo;
  3741.                 _requestElementName = null;
  3742.                 _requestElementNS = null;
  3743.                 _responseElementName = null;
  3744.                 _responseElementNS = null;
  3745.             }
  3746.            
  3747.             // Adds the request element
  3748.             internal void AddRequest(string name, string ns)
  3749.             {
  3750.                 Util.Log("RRMethod.AddRequest name " + name + " ns " + ns);
  3751.                 _requestElementName = name;
  3752.                 _requestElementNS = ns;
  3753.             }
  3754.            
  3755.             // Adds the response element
  3756.             internal void AddResponse(string name, string ns)
  3757.             {
  3758.                 Util.Log("RRMethod.AddResponse name " + name + " ns " + ns);
  3759.                 _responseElementName = name;
  3760.                 _responseElementNS = ns;
  3761.             }
  3762.            
  3763.             // Resolves the method
  3764.             internal override void ResolveTypes(WsdlParser parser)
  3765.             {
  3766.                 Util.Log("RRMethod.ResolveTypes " + _requestElementName + " " + _responseElementName);
  3767.                 ResolveWsdlParams(parser, _requestElementNS, _requestElementName, true, _wsdlMethodInfo);
  3768.                 ResolveWsdlParams(parser, _responseElementNS, _responseElementName, false, _wsdlMethodInfo);
  3769.                
  3770.                 if (_paramNamesOrder != null) {
  3771.                     // reorder parameters if there is a parameter order
  3772.                     object[] paramsInOrder = new object[_params.Count];
  3773.                     for (int i = 0; i < _params.Count; i++) {
  3774.                         paramsInOrder[(int)_paramPosition[i]] = _params[i];
  3775.                     }
  3776.                     _params = new ArrayList(paramsInOrder);
  3777.                 }
  3778.                
  3779.                 ResolveMethodAttributes();
  3780.                 //Needs to be after param order
  3781.                 return;
  3782.             }
  3783.            
  3784.             internal override void PrintCSC(TextWriter textWriter, string indentation, string namePrefix, string curNS, MethodPrintEnum methodPrintEnum, bool bURTType, string bodyPrefix, StringBuilder sb)
  3785.             {
  3786.                 Util.Log("RRMethod.PrintCSC name " + _requestElementName + " namePrefix " + namePrefix + " curNS " + curNS + " methodPrintEnum " + ((Enum)methodPrintEnum).ToString());
  3787.                 //if(bURTType == false)
  3788.                
  3789.                 // Don't want to generate a Finalize or destructor method
  3790.                 if (Name == "Finalize")
  3791.                     return;
  3792.                
  3793.                 bool bSoapAction = false;
  3794.                 if (SoapAction != null)
  3795.                     bSoapAction = true;
  3796.                
  3797.                 if ((bSoapAction || !bURTType) && !_wsdlMethodInfo.bProperty) {
  3798.                     sb.Length = 0;
  3799.                     sb.Append(indentation);
  3800.                     sb.Append("[SoapMethod(");
  3801.                    
  3802.                     if (bSoapAction) {
  3803.                         sb.Append("SoapAction=");
  3804.                         sb.Append(WsdlParser.IsValidUrl(SoapAction));
  3805.                     }
  3806.                     if (!bURTType) {
  3807.                         if (bSoapAction)
  3808.                             sb.Append(",");
  3809.                        
  3810.                         sb.Append("ResponseXmlElementName=");
  3811.                         sb.Append(WsdlParser.IsValidUrl(_responseElementName));
  3812.                         if (MethodType != null) {
  3813.                             sb.Append(", ReturnXmlElementName=");
  3814.                             sb.Append(WsdlParser.IsValidUrl(MethodType.Name));
  3815.                         }
  3816.                         sb.Append(", XmlNamespace=");
  3817.                         sb.Append(WsdlParser.IsValidUrl(_wsdlMethodInfo.inputMethodNameNs));
  3818.                         sb.Append(", ResponseXmlNamespace=");
  3819.                         sb.Append(WsdlParser.IsValidUrl(_wsdlMethodInfo.outputMethodNameNs));
  3820.                     }
  3821.                     sb.Append(")]");
  3822.                     textWriter.WriteLine(sb);
  3823.                 }
  3824.                
  3825.                 Util.Log("RRMethod.PrintCSC Invoke base PrintCSC");
  3826.                 base.PrintCSC(textWriter, indentation, namePrefix, curNS, methodPrintEnum, bURTType, bodyPrefix, sb);
  3827.                 return;
  3828.             }
  3829.            
  3830.             // Fields
  3831.             private string _requestElementName;
  3832.             private string _requestElementNS;
  3833.             //private String _requestTypeName;
  3834.             //private String _requestTypeNS;
  3835.             private string _responseElementName;
  3836.             private string _responseElementNS;
  3837.             private WsdlMethodInfo _wsdlMethodInfo;
  3838.             //private String _responseTypeName;
  3839.             //private String _responseTypeNS;
  3840.         }
  3841.        
  3842.         // Represents a oneway method
  3843.         internal class OnewayMethod : URTMethod
  3844.         {
  3845.             // Constructor
  3846.             internal OnewayMethod(string name, string soapAction, URTComplexType complexType) : base(name, soapAction, null, complexType)
  3847.             {
  3848.                 Util.Log("OnewayMethod.OnewayMethod name " + name + " soapAction " + soapAction);
  3849.                 _messageElementName = null;
  3850.                 _messageElementNS = null;
  3851.                 //_messageTypeName = null;
  3852.                 //_messageTypeNS = null;
  3853.             }
  3854.            
  3855.             internal OnewayMethod(WsdlMethodInfo wsdlMethodInfo, URTComplexType complexType) : base(wsdlMethodInfo.methodName, wsdlMethodInfo.soapAction, wsdlMethodInfo.methodAttributes, complexType)
  3856.             {
  3857.                 Util.Log("OnewayMethod.OnewayMethod WsdlMethodInfo name " + wsdlMethodInfo.methodName + " soapAction " + wsdlMethodInfo.soapAction);
  3858.                 _wsdlMethodInfo = wsdlMethodInfo;
  3859.                 _messageElementName = null;
  3860.                 _messageElementNS = null;
  3861.             }
  3862.            
  3863.            
  3864.             // Adds the request element
  3865.             internal void AddMessage(string name, string ns)
  3866.             {
  3867.                 Util.Log("OnewayMethod.AddMessage name " + name + " ns " + ns);
  3868.                 _messageElementName = name;
  3869.                 _messageElementNS = ns;
  3870.             }
  3871.            
  3872.             // Resolves the method
  3873.             internal override void ResolveTypes(WsdlParser parser)
  3874.             {
  3875.                 Util.Log("OnewayMethod.ResolveTypes name " + _messageElementName);
  3876.                 ResolveWsdlParams(parser, _messageElementNS, _messageElementName, true, _wsdlMethodInfo);
  3877.                 if (_paramNamesOrder != null) {
  3878.                     // reorder parameters if there is a parameter order
  3879.                     object[] paramsInOrder = new object[_params.Count];
  3880.                     for (int i = 0; i < _params.Count; i++) {
  3881.                         paramsInOrder[(int)_paramPosition[i]] = _params[i];
  3882.                     }
  3883.                     _params = new ArrayList(paramsInOrder);
  3884.                 }
  3885.                
  3886.                 ResolveMethodAttributes();
  3887.                 //Needs to be after param order
  3888.                 return;
  3889.             }
  3890.            
  3891.            
  3892.            
  3893.             // Writes the oneway attribute and delegates to the base implementation
  3894.             internal override void PrintCSC(TextWriter textWriter, string indentation, string namePrefix, string curNS, MethodPrintEnum methodPrintEnum, bool bURTType, string bodyPrefix, StringBuilder sb)
  3895.             {
  3896.                 Util.Log("OnewayMethod.PrintCSC name " + _messageElementName + " namePrefix " + namePrefix + " curNS " + curNS + " methodPrintEnum " + ((Enum)methodPrintEnum).ToString());
  3897.                
  3898.                 if (Name == "Finalize")
  3899.                     return;
  3900.                
  3901.                 bool bSoapAction = false;
  3902.                 if (SoapAction != null)
  3903.                     bSoapAction = true;
  3904.                
  3905.                 if (!(bSoapAction || !bURTType)) {
  3906.                     textWriter.Write(indentation);
  3907.                     textWriter.WriteLine("[OneWay]");
  3908.                 }
  3909.                 else {
  3910.                     sb.Length = 0;
  3911.                     sb.Append(indentation);
  3912.                     sb.Append("[OneWay, SoapMethod(");
  3913.                    
  3914.                     if (bSoapAction) {
  3915.                         sb.Append("SoapAction=");
  3916.                         sb.Append(WsdlParser.IsValidUrl(SoapAction));
  3917.                     }
  3918.                     if (!bURTType) {
  3919.                         if (bSoapAction)
  3920.                             sb.Append(",");
  3921.                        
  3922.                         sb.Append("XmlNamespace=");
  3923.                         sb.Append(WsdlParser.IsValidUrl(_wsdlMethodInfo.inputMethodNameNs));
  3924.                         //sb.Append(_messageElementNS);
  3925.                     }
  3926.                     sb.Append(")]");
  3927.                     textWriter.WriteLine(sb);
  3928.                 }
  3929.                
  3930.                
  3931.                 Util.Log("OnewayMethod.PrintCSC Invoke base PrintCSC");
  3932.                 base.PrintCSC(textWriter, indentation, namePrefix, curNS, methodPrintEnum, bURTType, bodyPrefix, sb);
  3933.                
  3934.                 return;
  3935.             }
  3936.            
  3937.             // Fields
  3938.             private string _messageElementName;
  3939.             private string _messageElementNS;
  3940.             private WsdlMethodInfo _wsdlMethodInfo;
  3941.             //private String _messageTypeName;
  3942.             //private String _messageTypeNS;
  3943.         }
  3944.        
  3945.         // Base class for interfaces
  3946.         internal abstract class BaseInterface
  3947.         {
  3948.             internal BaseInterface(string name, string urlNS, string ns, string encodedNS, WsdlParser parser)
  3949.             {
  3950.                 Util.Log("BaseInterface.BaseInterface");
  3951.                 _name = name;
  3952.                 _urlNS = urlNS;
  3953.                 _namespace = ns;
  3954.                 _encodedNS = encodedNS;
  3955.                 _parser = parser;
  3956.             }
  3957.             internal string Name {
  3958.                 get { return (_name); }
  3959.             }
  3960.             internal string UrlNS {
  3961.                 get { return (_urlNS); }
  3962.             }
  3963.             internal string Namespace {
  3964.                 get { return (_namespace); }
  3965.             }
  3966.            
  3967.             internal bool IsURTInterface {
  3968.                 get { return ((object)_namespace == (object)_encodedNS); }
  3969.             }
  3970.             internal string GetName(string curNS)
  3971.             {
  3972.                 string name;
  3973.                 if (_parser.Qualify(_namespace, curNS)) {
  3974.                     StringBuilder sb = new StringBuilder(_encodedNS, 50);
  3975.                     sb.Append('.');
  3976.                     sb.Append(WsdlParser.IsValidCS(_name));
  3977.                     name = sb.ToString();
  3978.                 }
  3979.                 else
  3980.                     name = _name;
  3981.                
  3982.                 Util.Log("BaseInterface.GetName curNS " + curNS);
  3983.                 return (name);
  3984.             }
  3985.             internal abstract void PrintClassMethods(TextWriter textWriter, string indentation, string curNS, ArrayList printedIFaces, bool bProxy, StringBuilder sb);
  3986.             private string _name;
  3987.             private string _urlNS;
  3988.             private string _namespace;
  3989.             private string _encodedNS;
  3990.             private WsdlParser _parser;
  3991.         }
  3992.        
  3993.         // Represents a system interface
  3994.         internal class SystemInterface : BaseInterface
  3995.         {
  3996.             internal SystemInterface(string name, string urlNS, string ns, WsdlParser parser, string assemName) : base(name, urlNS, ns, ns, parser)
  3997.             {
  3998.                 Util.Log("SystemInterface.SystemInterface");
  3999.                 Debug.Assert(ns.StartsWith("System", StringComparison.Ordinal), "Invalid System type");
  4000.                 string fullName = ns + '.' + name;
  4001.                
  4002.                 Assembly assem = null;
  4003.                 if (assemName == null)
  4004.                     assem = typeof(string).Assembly;
  4005.                 else
  4006.                     #pragma warning disable 618
  4007.                     assem = Assembly.LoadWithPartialName(assemName, null);
  4008.                 #pragma warning restore 618
  4009.                
  4010.                 if (assem == null)
  4011.                     throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_AssemblyNotFound"), assemName));
  4012.                
  4013.                 _type = assem.GetType(fullName, true);
  4014.             }
  4015.             internal override void PrintClassMethods(TextWriter textWriter, string indentation, string curNS, ArrayList printedIFaces, bool bProxy, StringBuilder sb)
  4016.             {
  4017.                 Util.Log("SystemInterface.PrintClassMethods " + curNS + " bProxy " + bProxy);
  4018.                 // Return if the interfaces have already been printed
  4019.                 int i;
  4020.                 for (i = 0; i < printedIFaces.Count; i++) {
  4021.                     if (printedIFaces[i] is SystemInterface) {
  4022.                         SystemInterface iface = (SystemInterface)printedIFaces[i];
  4023.                         if (iface._type == _type)
  4024.                             return;
  4025.                     }
  4026.                 }
  4027.                 printedIFaces.Add(this);
  4028.                
  4029.                 // Count of implemented methods
  4030.                 BindingFlags bFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public;
  4031.                 // | BindingFlags.NonPublic;
  4032.                 ArrayList types = new ArrayList();
  4033.                 sb.Length = 0;
  4034.                 types.Add(_type);
  4035.                 i = 0;
  4036.                 int j = 1;
  4037.                 while (i < j) {
  4038.                     Type type = (Type)types[i];
  4039.                     MethodInfo[] methods = type.GetMethods(bFlags);
  4040.                     Type[] iFaces = type.GetInterfaces();
  4041.                     for (int k = 0; k < iFaces.Length; k++) {
  4042.                         for (int l = 0; l < j; l++) {
  4043.                             if (types[i] == iFaces[k])
  4044.                                 goto Loopback;
  4045.                         }
  4046.                         types.Add(iFaces[k]);
  4047.                         j++;
  4048.                         Loopback:
  4049.                         continue;
  4050.                     }
  4051.                    
  4052.                     for (int k = 0; k < methods.Length; k++) {
  4053.                         MethodInfo method = methods[k];
  4054.                         sb.Length = 0;
  4055.                         sb.Append(indentation);
  4056.                         sb.Append(CSharpTypeString(method.ReturnType.FullName));
  4057.                         sb.Append(' ');
  4058.                         sb.Append(WsdlParser.IsValidCS(type.FullName));
  4059.                         sb.Append('.');
  4060.                         sb.Append(WsdlParser.IsValidCS(method.Name));
  4061.                         sb.Append('(');
  4062.                         ParameterInfo[] parameters = method.GetParameters();
  4063.                         for (int l = 0; l < parameters.Length; l++) {
  4064.                             if (l != 0)
  4065.                                 sb.Append(", ");
  4066.                             ParameterInfo param = parameters[l];
  4067.                             Type parameterType = param.ParameterType;
  4068.                             if (param.IsIn)
  4069.                                 sb.Append("in ");
  4070.                             else if (param.IsOut)
  4071.                                 sb.Append("out ");
  4072.                             else if (parameterType.IsByRef) {
  4073.                                 sb.Append("ref ");
  4074.                                 parameterType = parameterType.GetElementType();
  4075.                             }
  4076.                             sb.Append(CSharpTypeString(parameterType.FullName));
  4077.                             sb.Append(' ');
  4078.                             sb.Append(WsdlParser.IsValidCS(param.Name));
  4079.                         }
  4080.                         sb.Append(')');
  4081.                         textWriter.WriteLine(sb);
  4082.                        
  4083.                         textWriter.Write(indentation);
  4084.                         textWriter.WriteLine('{');
  4085.                        
  4086.                         string newIndentation = indentation + " ";
  4087.                         if (bProxy == false) {
  4088.                             for (int l = 0; l < parameters.Length; l++) {
  4089.                                 ParameterInfo param = parameters[l];
  4090.                                 Type parameterType = param.ParameterType;
  4091.                                 if (param.IsOut) {
  4092.                                     sb.Length = 0;
  4093.                                     sb.Append(newIndentation);
  4094.                                     sb.Append(WsdlParser.IsValidCS(param.Name));
  4095.                                     sb.Append(URTMethod.ValueString(CSharpTypeString(param.ParameterType.FullName)));
  4096.                                     sb.Append(';');
  4097.                                     textWriter.WriteLine(sb);
  4098.                                 }
  4099.                             }
  4100.                            
  4101.                             Util.Log("SystemInterface.PrintClassMethods return 1 print");
  4102.                             sb.Length = 0;
  4103.                             sb.Append(newIndentation);
  4104.                             sb.Append("return");
  4105.                             string valueString = URTMethod.ValueString(CSharpTypeString(method.ReturnType.FullName));
  4106.                             if (valueString != null) {
  4107.                                 sb.Append('(');
  4108.                                 sb.Append(valueString);
  4109.                                 sb.Append(')');
  4110.                             }
  4111.                             sb.Append(';');
  4112.                         }
  4113.                         else {
  4114.                             Util.Log("SystemInterface.PrintClassMethods return 2 print");
  4115.                             sb.Length = 0;
  4116.                             sb.Append(newIndentation);
  4117.                             sb.Append("return((");
  4118.                             sb.Append(WsdlParser.IsValidCS(type.FullName));
  4119.                             sb.Append(") _tp).");
  4120.                             sb.Append(WsdlParser.IsValidCS(method.Name));
  4121.                             sb.Append('(');
  4122.                             if (parameters.Length > 0) {
  4123.                                 int lastParameter = parameters.Length - 1;
  4124.                                 for (int l = 0; l < parameters.Length; l++) {
  4125.                                     ParameterInfo param = parameters[0];
  4126.                                     Type parameterType = param.ParameterType;
  4127.                                     if (param.IsIn)
  4128.                                         sb.Append("in ");
  4129.                                     else if (param.IsOut)
  4130.                                         sb.Append("out ");
  4131.                                     else if (parameterType.IsByRef)
  4132.                                         sb.Append("ref ");
  4133.                                     sb.Append(WsdlParser.IsValidCS(param.Name));
  4134.                                     if (l < lastParameter)
  4135.                                         sb.Append(", ");
  4136.                                 }
  4137.                             }
  4138.                             sb.Append(");");
  4139.                         }
  4140.                         textWriter.WriteLine(sb);
  4141.                        
  4142.                         textWriter.Write(indentation);
  4143.                         textWriter.WriteLine('}');
  4144.                     }
  4145.                    
  4146.                     ++i;
  4147.                 }
  4148.                
  4149.                 return;
  4150.             }
  4151.             private static string CSharpTypeString(string typeName)
  4152.             {
  4153.                 Util.Log("SystemInterface.CSharpTypeString typeName " + typeName);
  4154.                 string CSCTypeName = typeName;
  4155.                 if (typeName == "System.SByte")
  4156.                     CSCTypeName = "sbyte";
  4157.                 else if (typeName == "System.byte")
  4158.                     CSCTypeName = "byte";
  4159.                 else if (typeName == "System.Int16")
  4160.                     CSCTypeName = "short";
  4161.                 else if (typeName == "System.UInt16")
  4162.                     CSCTypeName = "ushort";
  4163.                 else if (typeName == "System.Int32")
  4164.                     CSCTypeName = "int";
  4165.                 else if (typeName == "System.UInt32")
  4166.                     CSCTypeName = "uint";
  4167.                 else if (typeName == "System.Int64")
  4168.                     CSCTypeName = "long";
  4169.                 else if (typeName == "System.UInt64")
  4170.                     CSCTypeName = "ulong";
  4171.                 else if (typeName == "System.Char")
  4172.                     CSCTypeName = "char";
  4173.                 else if (typeName == "System.Single")
  4174.                     CSCTypeName = "float";
  4175.                 else if (typeName == "System.Double")
  4176.                     CSCTypeName = "double";
  4177.                 else if (typeName == "System.Boolean")
  4178.                     CSCTypeName = "boolean";
  4179.                 else if (typeName == "System.Void")
  4180.                     CSCTypeName = "void";
  4181.                 else if (typeName == "System.String")
  4182.                     CSCTypeName = "String";
  4183.                
  4184.                 return (WsdlParser.IsValidCSAttr(CSCTypeName));
  4185.             }
  4186.            
  4187.             Type _type;
  4188.         }
  4189.        
  4190.         // Represents an interface
  4191.        
  4192.         internal class URTInterface : BaseInterface
  4193.         {
  4194.             internal URTInterface(string name, string urlNS, string ns, string encodedNS, WsdlParser parser) : base(name, urlNS, ns, encodedNS, parser)
  4195.             {
  4196.                 Util.Log("URTInterface.URTInterface name " + name + " ns " + ns + " encodedNS " + encodedNS);
  4197.                 _baseIFaces = new ArrayList();
  4198.                 _baseIFaceNames = new ArrayList();
  4199.                 _extendsInterface = new ArrayList();
  4200.                 _methods = new ArrayList();
  4201.                 _parser = parser;
  4202.             }
  4203.             internal void Extends(string baseName, string baseNS, WsdlParser parser)
  4204.             {
  4205.                 Util.Log("URTInterface.Extends baseName " + baseName + " baseNSf " + baseNS);
  4206.                 _baseIFaceNames.Add(baseName);
  4207.                 _baseIFaceNames.Add(baseNS);
  4208.                 // Urt namespace will not have schema, they need to be recorded.
  4209.                 URTNamespace parsingNamespace = parser.AddNewNamespace(baseNS);
  4210.                 /*
  4211.                 if (parsingNamespace == null)
  4212.                 {
  4213.                     parsingNamespace = new URTNamespace(baseNS, parser);
  4214.                 }
  4215.                 */               
  4216.                
  4217. URTInterface parsingInterface = parsingNamespace.LookupInterface(baseName);
  4218.                 if (parsingInterface == null) {
  4219.                     parsingInterface = new URTInterface(baseName, parsingNamespace.Name, parsingNamespace.Namespace, parsingNamespace.EncodedNS, parser);
  4220.                     parsingNamespace.AddInterface(parsingInterface);
  4221.                 }
  4222.                 _extendsInterface.Add(parsingInterface);
  4223.             }
  4224.            
  4225.             internal void AddMethod(URTMethod method)
  4226.             {
  4227.                 Util.Log("URTInterface.AddMethod method " + method.Name);
  4228.                 _methods.Add(method);
  4229.                 method.MethodFlags = MethodFlags.None;
  4230.                 // method names don't have public modifiers
  4231.             }
  4232.            
  4233.             // Check if interface method occurs up the inheritance hierarchy
  4234.             internal void NewNeeded(URTMethod method)
  4235.             {
  4236.                 Util.Log("URTInterface.NewNeeded Enter interface " + Name + " method " + method.Name);
  4237.                 foreach (URTInterface urtInterface in _extendsInterface) {
  4238.                     urtInterface.CheckIfNewNeeded(method);
  4239.                     if (URTMethod.MethodFlagsTest(method.MethodFlags, MethodFlags.New))
  4240.                         break;
  4241.                    
  4242.                 }
  4243.                 Util.Log("URTInterface.NewNeeded Exit interface " + Name + " method " + method.Name + " " + ((Enum)method.MethodFlags).ToString());
  4244.             }
  4245.            
  4246.             // Check this interface for method
  4247.             private void CheckIfNewNeeded(URTMethod method)
  4248.             {
  4249.                 foreach (URTMethod urtMethod in _methods) {
  4250.                     if (urtMethod.Name == method.Name) {
  4251.                         method.MethodFlags |= MethodFlags.New;
  4252.                         break;
  4253.                     }
  4254.                 }
  4255.                
  4256.                 if (URTMethod.MethodFlagsTest(method.MethodFlags, MethodFlags.New))
  4257.                     NewNeeded(method);
  4258.             }
  4259.            
  4260.             internal void ResolveTypes(WsdlParser parser)
  4261.             {
  4262.                 Util.Log("URTInterface.ResolveTypes " + Name);
  4263.                 for (int i = 0; i < _baseIFaceNames.Count; i = i + 2) {
  4264.                     string baseIFaceName = (string)_baseIFaceNames[i];
  4265.                     string baseIFaceXmlNS = (string)_baseIFaceNames[i + 1];
  4266.                     string baseIFaceNS;
  4267.                     string baseIFaceAssemName;
  4268.                     BaseInterface iFace;
  4269.                     UrtType iType = parser.IsURTExportedType(baseIFaceXmlNS, out baseIFaceNS, out baseIFaceAssemName);
  4270.                    
  4271.                     Util.Log("URTInterface.ResolveTypes Is System " + Name + " iType " + ((Enum)iType).ToString() + " baseIFaceNS " + baseIFaceNS);
  4272.                     if ((iType != UrtType.Interop) && baseIFaceNS.StartsWith("System", StringComparison.Ordinal)) {
  4273.                         iFace = new SystemInterface(baseIFaceName, baseIFaceXmlNS, baseIFaceNS, _parser, baseIFaceAssemName);
  4274.                     }
  4275.                     else {
  4276.                         URTNamespace ns = parser.LookupNamespace(baseIFaceXmlNS);
  4277.                         if (ns == null) {
  4278.                             throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), baseIFaceXmlNS, baseIFaceName));
  4279.                         }
  4280.                         iFace = ns.LookupInterface(baseIFaceName);
  4281.                         if (iFace == null) {
  4282.                             throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), baseIFaceName, baseIFaceXmlNS));
  4283.                         }
  4284.                     }
  4285.                     _baseIFaces.Add(iFace);
  4286.                 }
  4287.                 for (int i = 0; i < _methods.Count; i++)
  4288.                     ((URTMethod)_methods[i]).ResolveTypes(parser);
  4289.             }
  4290.             internal void PrintCSC(TextWriter textWriter, string indentation, string curNS, StringBuilder sb)
  4291.             {
  4292.                 Util.Log("URTInterface.PrintCSC name " + Name + " curNS " + curNS);
  4293.                 bool bURTType = IsURTInterface;
  4294.                
  4295.                 sb.Length = 0;
  4296.                 sb.Append("\n");
  4297.                 sb.Append(indentation);
  4298.                 sb.Append("[SoapType(");
  4299.                
  4300.                 if (_parser._xsdVersion == XsdVersion.V1999) {
  4301.                     sb.Append("SoapOptions=SoapOption.Option1|SoapOption.AlwaysIncludeTypes|SoapOption.XsdString|SoapOption.EmbedAll,");
  4302.                 }
  4303.                 else if (_parser._xsdVersion == XsdVersion.V2000) {
  4304.                     sb.Append("SoapOptions=SoapOption.Option2|SoapOption.AlwaysIncludeTypes|SoapOption.XsdString|SoapOption.EmbedAll,");
  4305.                 }
  4306.                
  4307.                 if (!bURTType) {
  4308.                     sb.Append("XmlElementName=");
  4309.                     sb.Append(WsdlParser.IsValidUrl(Name));
  4310.                     sb.Append(", XmlNamespace=");
  4311.                     sb.Append(WsdlParser.IsValidUrl(Namespace));
  4312.                     sb.Append(", XmlTypeName=");
  4313.                     sb.Append(WsdlParser.IsValidUrl(Name));
  4314.                     sb.Append(", XmlTypeNamespace=");
  4315.                     sb.Append(WsdlParser.IsValidUrl(Namespace));
  4316.                 }
  4317.                 else {
  4318.                     // Need namespace for clr type because proxy dll might have a different name than server dll
  4319.                     sb.Append("XmlNamespace=");
  4320.                     sb.Append(WsdlParser.IsValidUrl(UrlNS));
  4321.                     sb.Append(", XmlTypeNamespace=");
  4322.                     sb.Append(WsdlParser.IsValidUrl(UrlNS));
  4323.                 }
  4324.                
  4325.                 sb.Append(")]");
  4326.                 sb.Append("[ComVisible(true)]");
  4327.                 textWriter.WriteLine(sb);
  4328.                
  4329.                 sb.Length = 0;
  4330.                 sb.Append(indentation);
  4331.                 sb.Append("public interface ");
  4332.                 sb.Append(WsdlParser.IsValidCS(Name));
  4333.                
  4334.                 if (_baseIFaces.Count > 0)
  4335.                     sb.Append(" : ");
  4336.                
  4337.                 if (_baseIFaces.Count > 0) {
  4338.                     sb.Append(WsdlParser.IsValidCSAttr(((BaseInterface)_baseIFaces[0]).GetName(curNS)));
  4339.                     for (int i = 1; i < _baseIFaces.Count; i++) {
  4340.                         sb.Append(", ");
  4341.                         sb.Append(WsdlParser.IsValidCSAttr(((BaseInterface)_baseIFaces[i]).GetName(curNS)));
  4342.                     }
  4343.                 }
  4344.                
  4345.                 textWriter.WriteLine(sb);
  4346.                
  4347.                 textWriter.Write(indentation);
  4348.                 textWriter.WriteLine('{');
  4349.                
  4350.                 string newIndentation = indentation + " ";
  4351.                 string namePrefix = " ";
  4352.                 Util.Log("URTInterface.PrintCSC method count " + _methods.Count);
  4353.                
  4354.                 for (int i = 0; i < _methods.Count; i++) {
  4355.                     Util.Log("URTInterface.PrintCSC Invoke methods in Interface PrintCSC " + Name + " methodName " + ((URTMethod)_methods[i]).Name);
  4356.                     NewNeeded((URTMethod)_methods[i]);
  4357.                     ((URTMethod)_methods[i]).PrintCSC(textWriter, newIndentation, namePrefix, curNS, MethodPrintEnum.InterfaceMethods, bURTType, null, sb);
  4358.                 }
  4359.                 textWriter.Write(indentation);
  4360.                 textWriter.WriteLine('}');
  4361.             }
  4362.            
  4363.             // No longer used
  4364.             internal override void PrintClassMethods(TextWriter textWriter, string indentation, string curNS, ArrayList printedIFaces, bool bProxy, StringBuilder sb)
  4365.             {
  4366.                 Util.Log("URTInterface.PrintClassMethods method " + Name + " curNS " + curNS + " bProxy " + bProxy);
  4367.                 // Return if the interface has already been printed
  4368.                 for (int i = 0; i < printedIFaces.Count; i++) {
  4369.                     if (printedIFaces[i] == this) {
  4370.                         Util.Log("URTInterface.PrintClassMethods printedIFaces return " + Name);
  4371.                         return;
  4372.                     }
  4373.                 }
  4374.                 Util.Log("URTInterface.PrintClassMethods method 2 " + Name + " _methods.Count " + _methods.Count);
  4375.                 printedIFaces.Add(this);
  4376.                 sb.Length = 0;
  4377.                 sb.Append(indentation);
  4378.                 if (_methods.Count > 0) {
  4379.                     sb.Append("// ");
  4380.                     sb.Append(WsdlParser.IsValidCS(Name));
  4381.                     sb.Append(" interface Methods");
  4382.                     textWriter.WriteLine(sb);
  4383.                    
  4384.                     sb.Length = 0;
  4385.                     sb.Append(' ');
  4386.                     string ifaceName = GetName(curNS);
  4387.                     sb.Append(WsdlParser.IsValidCS(ifaceName));
  4388.                     sb.Append('.');
  4389.                     string namePrefix = sb.ToString();
  4390.                    
  4391.                     string bodyPrefix = null;
  4392.                     if (bProxy) {
  4393.                         sb.Length = 0;
  4394.                         sb.Append("((");
  4395.                         sb.Append(WsdlParser.IsValidCS(ifaceName));
  4396.                         sb.Append(") _tp).");
  4397.                         bodyPrefix = sb.ToString();
  4398.                     }
  4399.                    
  4400.                     MethodPrintEnum methodPrintEnum = MethodPrintEnum.PrintBody | MethodPrintEnum.InterfaceInClass;
  4401.                     for (int i = 0; i < _methods.Count; i++) {
  4402.                         Util.Log("URTInterface.PrintClassMethods URTMethod invoke interface methods in class PrintCSC " + Name + " methodName " + ((URTMethod)_methods[i]));
  4403.                        
  4404.                         ((URTMethod)_methods[i]).PrintCSC(textWriter, indentation, namePrefix, curNS, methodPrintEnum, true, bodyPrefix, sb);
  4405.                     }
  4406.                 }
  4407.                
  4408.                 for (int i = 0; i < _baseIFaces.Count; i++) {
  4409.                     Util.Log("URTInterface.PrintClassMethods BaseIFaces " + Name);
  4410.                     ((BaseInterface)_baseIFaces[i]).PrintClassMethods(textWriter, indentation, curNS, printedIFaces, bProxy, sb);
  4411.                 }
  4412.             }
  4413.            
  4414.             private WsdlParser _parser;
  4415.             private ArrayList _baseIFaces;
  4416.             private ArrayList _baseIFaceNames;
  4417.             private ArrayList _methods;
  4418.             private ArrayList _extendsInterface;
  4419.         }
  4420.        
  4421.         // Represents a field of a type
  4422.         internal class URTField
  4423.         {
  4424.             internal URTField(string name, string typeName, string xmlNS, WsdlParser parser, bool bPrimitive, bool bEmbedded, bool bAttribute, bool bOptional, bool bArray, string arraySize,
  4425.             URTNamespace urtNamespace)
  4426.             {
  4427.                 Util.Log("URTField.URTField " + name + " typeName " + typeName + " xmlNS " + xmlNS + " bPrimitive " + bPrimitive + " bEmbedded " + bEmbedded + " bAttribute " + bAttribute);
  4428.                 _name = name;
  4429.                 _typeName = typeName;
  4430.                 _parser = parser;
  4431.                 string typeAssemName;
  4432.                
  4433.                 UrtType urtType = parser.IsURTExportedType(xmlNS, out _typeNS, out typeAssemName);
  4434.                 if (urtType == UrtType.Interop)
  4435.                     _encodedNS = urtNamespace.EncodedNS;
  4436.                 else
  4437.                     _encodedNS = _typeNS;
  4438.                 _primitiveField = bPrimitive;
  4439.                 _embeddedField = bEmbedded;
  4440.                 _attributeField = bAttribute;
  4441.                 _optionalField = bOptional;
  4442.                 _arrayField = bArray;
  4443.                 _arraySize = arraySize;
  4444.                 _urtNamespace = urtNamespace;
  4445.             }
  4446.             internal string TypeName {
  4447.                 get {
  4448.                     if (_arrayField)
  4449.                         return (_typeName + "[]");
  4450.                     return (_typeName);
  4451.                 }
  4452.             }
  4453.             internal string TypeNS {
  4454.                 get { return (_typeNS); }
  4455.             }
  4456.             internal bool IsPrimitive {
  4457.                 get { return (_primitiveField); }
  4458.             }
  4459.             internal bool IsArray {
  4460.                 get { return (_arrayField); }
  4461.             }
  4462.             internal string GetTypeString(string curNS, bool bNS)
  4463.             {
  4464.                 return _parser.GetTypeString(curNS, bNS, _urtNamespace, TypeName, _typeNS);
  4465.             }
  4466.            
  4467.             internal void PrintCSC(TextWriter textWriter, string indentation, string curNS, StringBuilder sb)
  4468.             {
  4469.                 Util.Log("URTField.PrintCSC name " + _name + " curNS" + curNS);
  4470.                 if (_embeddedField) {
  4471.                     textWriter.Write(indentation);
  4472.                     textWriter.WriteLine("[SoapField(Embedded=true)]");
  4473.                 }
  4474.                
  4475.                 sb.Length = 0;
  4476.                 sb.Append(indentation);
  4477.                 sb.Append("public ");
  4478.                 sb.Append(WsdlParser.IsValidCSAttr(GetTypeString(curNS, true)));
  4479.                 sb.Append(' ');
  4480.                 sb.Append(WsdlParser.IsValidCS(_name));
  4481.                 sb.Append(';');
  4482.                 textWriter.WriteLine(sb);
  4483.             }
  4484.            
  4485.             private string _name;
  4486.             private string _typeName;
  4487.             private string _typeNS;
  4488.             private string _encodedNS;
  4489.             private bool _primitiveField;
  4490.             private bool _embeddedField;
  4491.             private bool _attributeField;
  4492.             private bool _optionalField;
  4493.             private bool _arrayField;
  4494.             private string _arraySize;
  4495.             private WsdlParser _parser;
  4496.             private URTNamespace _urtNamespace;
  4497.         }
  4498.        
  4499.         internal abstract class SchemaFacet
  4500.         {
  4501.             protected SchemaFacet()
  4502.             {
  4503.             }
  4504.             internal virtual void ResolveTypes(WsdlParser parser)
  4505.             {
  4506.             }
  4507.             internal abstract void PrintCSC(TextWriter textWriter, string newIndentation, string curNS, StringBuilder sb);
  4508.         }
  4509.        
  4510.         internal class EnumFacet : SchemaFacet
  4511.         {
  4512.             internal EnumFacet(string valueString, int value) : base()
  4513.             {
  4514.                 Util.Log("EnumFacet.EnumFacet valueString " + valueString + " value " + value);
  4515.                 _valueString = valueString;
  4516.                 _value = value;
  4517.             }
  4518.             internal override void PrintCSC(TextWriter textWriter, string newIndentation, string curNS, StringBuilder sb)
  4519.             {
  4520.                 Util.Log("EnumFacet.PrintCSC _valueString " + _valueString + " value " + _value + " curNS " + curNS);
  4521.                 sb.Length = 0;
  4522.                 sb.Append(newIndentation);
  4523.                 sb.Append(WsdlParser.IsValidCS(_valueString));
  4524.                 sb.Append(" = ");
  4525.                 sb.Append(_value);
  4526.                 sb.Append(',');
  4527.                 textWriter.WriteLine(sb);
  4528.                 return;
  4529.             }
  4530.            
  4531.             private string _valueString;
  4532.             private int _value;
  4533.         }
  4534.        
  4535.         // Represents a Base type
  4536.         internal abstract class BaseType
  4537.         {
  4538.             internal BaseType(string name, string urlNS, string ns, string encodedNS)
  4539.             {
  4540.                 _searchName = name;
  4541.                 _name = name;
  4542.                 _urlNS = urlNS;
  4543.                 _namespace = ns;
  4544.                 _elementName = _name;
  4545.                 _elementNS = ns;
  4546.                 _encodedNS = encodedNS;
  4547.                 Util.Log("BaseType.BaseType in name " + name + " storedname " + _name + " nested " + _bNestedType);
  4548.             }
  4549.             internal string Name {
  4550.                 get { return (_name); }
  4551.                 set { _name = value; }
  4552.             }
  4553.            
  4554.             internal string SearchName {
  4555.                 get { return (_searchName); }
  4556.                 set { _searchName = value; }
  4557.             }
  4558.            
  4559.             internal string OuterTypeName {
  4560.                 set { _outerTypeName = value; }
  4561.             }
  4562.            
  4563.            
  4564.            
  4565.             internal string NestedTypeName {
  4566.                 get { return (_nestedTypeName); }
  4567.                 set { _nestedTypeName = value; }
  4568.             }
  4569.            
  4570.             internal string FullNestedTypeName {
  4571.                 set { _fullNestedTypeName = value; }
  4572.             }
  4573.            
  4574.             internal bool bNestedType {
  4575.                 get { return (_bNestedType); }
  4576.                 set { _bNestedType = value; }
  4577.             }
  4578.            
  4579.             internal bool bNestedTypePrint {
  4580.                 get { return (_bNestedTypePrint); }
  4581.                 set { _bNestedTypePrint = value; }
  4582.             }
  4583.            
  4584.             internal string UrlNS {
  4585.                 get { return (_urlNS); }
  4586.             }
  4587.            
  4588.             internal string Namespace {
  4589.                 get { return (_namespace); }
  4590.             }
  4591.            
  4592.             internal string ElementName {
  4593.                 set { _elementName = value; }
  4594.             }
  4595.             internal string ElementNS {
  4596.                 set { _elementNS = value; }
  4597.             }
  4598.            
  4599.             internal bool IsURTType {
  4600.                 get {
  4601.                     Util.Log("BaseType.IsURTType _namespace " + _namespace + " _encodedNS " + _encodedNS + " " + ((object)_namespace == (object)_encodedNS));
  4602.                     return ((object)_namespace == (object)_encodedNS);
  4603.                 }
  4604.             }
  4605.            
  4606.             internal virtual string GetName(string curNS)
  4607.             {
  4608.                 string name;
  4609.                 if (MatchingStrings(_namespace, curNS))
  4610.                     name = _name;
  4611.                 else {
  4612.                     StringBuilder sb = new StringBuilder(_encodedNS, 50);
  4613.                     sb.Append('.');
  4614.                     sb.Append(WsdlParser.IsValidCS(_name));
  4615.                     name = sb.ToString();
  4616.                 }
  4617.                
  4618.                 return (name);
  4619.             }
  4620.             internal abstract MethodFlags GetMethodFlags(URTMethod method);
  4621.             internal abstract bool IsEmittableFieldType {
  4622.                 get;
  4623.             }
  4624.             internal abstract string FieldName {
  4625.                 get;
  4626.             }
  4627.            
  4628.             internal abstract string FieldNamespace {
  4629.                 get;
  4630.             }
  4631.            
  4632.             internal abstract bool PrimitiveField {
  4633.                 get;
  4634.             }
  4635.            
  4636.             private string _name;
  4637.             private string _searchName;
  4638.             private string _urlNS;
  4639.             private string _namespace;
  4640.             private string _elementName;
  4641.             private string _elementNS;
  4642.             private string _encodedNS;
  4643.             internal ArrayList _nestedTypes;
  4644.             // nested types within this type
  4645.             internal string _nestedTypeName;
  4646.             //If this type is nested, name of nested type (without + mangle)
  4647.             internal string _fullNestedTypeName;
  4648.             //If this type is nested, name of nested type (without + mangle) with outer class qualifier
  4649.             internal string _outerTypeName;
  4650.             internal bool _bNestedType = false;
  4651.             //Contains nested types
  4652.             internal bool _bNestedTypePrint = false;
  4653.         }
  4654.        
  4655.         // Representa a system type
  4656.         internal class SystemType : BaseType
  4657.         {
  4658.             internal SystemType(string name, string urlNS, string ns, string assemName) : base(name, urlNS, ns, ns)
  4659.             {
  4660.                 Util.Log("SystemType.SystemType name " + name + " ns " + ns + " assemName " + assemName);
  4661.                 Debug.Assert(ns.StartsWith("System", StringComparison.Ordinal), "Invalid System type");
  4662.                
  4663.                 string fullName = ns + '.' + name;
  4664.                
  4665.                 Assembly assem = null;
  4666.                 if (assemName == null)
  4667.                     assem = typeof(string).Assembly;
  4668.                 else
  4669.                     #pragma warning disable 618
  4670.                     assem = Assembly.LoadWithPartialName(assemName, null);
  4671.                 #pragma warning restore 618
  4672.                
  4673.                 if (assem == null)
  4674.                     throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_AssemblyNotFound"), assemName));
  4675.                
  4676.                 _type = assem.GetType(fullName, true);
  4677.             }
  4678.             internal override MethodFlags GetMethodFlags(URTMethod method)
  4679.             {
  4680.                 BindingFlags bFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
  4681.                 Type type = _type;
  4682.                 while (type != null) {
  4683.                     MethodInfo[] methods = type.GetMethods(bFlags);
  4684.                     for (int i = 0; i < methods.Length; i++) {
  4685.                         MethodFlags methodFlags = method.GetMethodFlags(methods[i]);
  4686.                         if (methodFlags != 0)
  4687.                             return (methodFlags);
  4688.                     }
  4689.                     type = type.BaseType;
  4690.                 }
  4691.                
  4692.                 return (0);
  4693.             }
  4694.             internal override bool IsEmittableFieldType {
  4695.                 get { return (true); }
  4696.             }
  4697.            
  4698.             internal override string FieldName {
  4699.                 get { return (null); }
  4700.             }
  4701.             internal override string FieldNamespace {
  4702.                 get { return (null); }
  4703.             }
  4704.             internal override bool PrimitiveField {
  4705.                 get { return (false); }
  4706.             }
  4707.            
  4708.             private Type _type;
  4709.         }
  4710.        
  4711.         // Represents a simple type
  4712.         internal class URTSimpleType : BaseType
  4713.         {
  4714.             internal URTSimpleType(string name, string urlNS, string ns, string encodedNS, bool bAnonymous, WsdlParser parser) : base(name, urlNS, ns, encodedNS)
  4715.             {
  4716.                 Util.Log("URTSimpleType.URTSimpleType name " + name + " ns " + ns + " encodedNS " + encodedNS + " bAnonymous " + bAnonymous);
  4717.                 _baseTypeName = null;
  4718.                 _baseTypeXmlNS = null;
  4719.                 _baseType = null;
  4720.                 _fieldString = null;
  4721.                 _facets = new ArrayList();
  4722.                 _bEnum = false;
  4723.                 _bAnonymous = bAnonymous;
  4724.                 _encoding = null;
  4725.                 _parser = parser;
  4726.             }
  4727.            
  4728.             internal void Extends(string baseTypeName, string baseTypeNS)
  4729.             {
  4730.                 Util.Log("URTSimpleType.Extends baseTypeName " + baseTypeName + " baseTypeNS " + baseTypeNS);
  4731.                 _baseTypeName = baseTypeName;
  4732.                 _baseTypeXmlNS = baseTypeNS;
  4733.                
  4734.             }
  4735.            
  4736.             internal bool IsEnum {
  4737.                 get { return (_bEnum); }
  4738.                 set { _bEnum = value; }
  4739.             }
  4740.            
  4741.             internal string EnumType {
  4742.                 set {
  4743.                     string typeName = value;
  4744.                     string typeNS = _parser.ParseQName(ref typeName);
  4745.                     if (typeName != null && typeName.Length > 0)
  4746.                         _enumType = MapToEnumType(_parser.MapSchemaTypesToCSharpTypes(typeName));
  4747.                    
  4748.                 }
  4749.             }
  4750.            
  4751.             private string MapToEnumType(string type)
  4752.             {
  4753.                 string etype = null;
  4754.                 if (type == "Byte")
  4755.                     etype = "byte";
  4756.                 else if (type == "SByte")
  4757.                     etype = "sbyte";
  4758.                 else if (type == "Int16")
  4759.                     etype = "short";
  4760.                 else if (type == "UInt16")
  4761.                     etype = "ushort";
  4762.                 else if (type == "Int32")
  4763.                     etype = "int";
  4764.                 else if (type == "UInt32")
  4765.                     etype = "uint";
  4766.                 else if (type == "Int64")
  4767.                     etype = "long";
  4768.                 else if (type == "UInt64")
  4769.                     etype = "ulong";
  4770.                 else
  4771.                     throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_InvalidEnumType"), type));
  4772.                
  4773.                 return etype;
  4774.             }
  4775.            
  4776.             internal void AddFacet(SchemaFacet facet)
  4777.             {
  4778.                 Util.Log("URTSimpleType.AddFacet");
  4779.                 _facets.Add(facet);
  4780.             }
  4781.            
  4782.             internal override bool IsEmittableFieldType {
  4783.                 get {
  4784.                     if (_fieldString == null) {
  4785.                         if ((_bAnonymous == true) && (_facets.Count == 0) && (_encoding != null) && (_baseTypeName == "binary") && (_parser.MatchingSchemaStrings(_baseTypeXmlNS)))
  4786.                             _fieldString = "byte[]";
  4787.                         else
  4788.                             _fieldString = String.Empty;
  4789.                     }
  4790.                    
  4791.                     return (_fieldString != String.Empty);
  4792.                 }
  4793.             }
  4794.             internal override string FieldName {
  4795.                 get { return (_fieldString); }
  4796.             }
  4797.            
  4798.             internal override string FieldNamespace {
  4799.                 get {
  4800.                     string schemaStr = null;
  4801.                     if (_parser._xsdVersion == XsdVersion.V1999)
  4802.                         schemaStr = s_schemaNamespaceString1999;
  4803.                     else if (_parser._xsdVersion == XsdVersion.V2000)
  4804.                         schemaStr = s_schemaNamespaceString2000;
  4805.                     else if (_parser._xsdVersion == XsdVersion.V2001)
  4806.                         schemaStr = s_schemaNamespaceString;
  4807.                     return schemaStr;
  4808.                 }
  4809.             }
  4810.            
  4811.             internal override bool PrimitiveField {
  4812.                 get { return (true); }
  4813.             }
  4814.            
  4815.             internal override string GetName(string curNS)
  4816.             {
  4817.                 if ((_fieldString != null) && (_fieldString != String.Empty))
  4818.                     return (_fieldString);
  4819.                
  4820.                 Util.Log("URTSimpleType.GetName curNS " + curNS + " return " + base.GetName(curNS));
  4821.                 return (base.GetName(curNS));
  4822.             }
  4823.            
  4824.             internal void PrintCSC(TextWriter textWriter, string indentation, string curNS, StringBuilder sb)
  4825.             {
  4826.                 Util.Log("URTSimpleType.PrintCSC name " + Name + " curNS " + curNS);
  4827.                
  4828.                 // Print only if the type is not an emittable field type
  4829.                 if (IsEmittableFieldType == true)
  4830.                     return;
  4831.                
  4832.                 if (bNestedType && !bNestedTypePrint)
  4833.                     return;
  4834.                
  4835.                 // Handle encoding
  4836.                 if (_encoding != null) {
  4837.                     // sb.Length = 0;
  4838.                     // sb.Append(indentation);
  4839.                 }
  4840.                
  4841.                 sb.Length = 0;
  4842.                 sb.Append("\n");
  4843.                 sb.Append(indentation);
  4844.                 sb.Append("[");
  4845.                 sb.Append("Serializable, ");
  4846.                 sb.Append("SoapType(");
  4847.                
  4848.                 if (_parser._xsdVersion == XsdVersion.V1999) {
  4849.                     sb.Append("SoapOptions=SoapOption.Option1|SoapOption.AlwaysIncludeTypes|SoapOption.XsdString|SoapOption.EmbedAll,");
  4850.                 }
  4851.                 else if (_parser._xsdVersion == XsdVersion.V2000) {
  4852.                     sb.Append("SoapOptions=SoapOption.Option2|SoapOption.AlwaysIncludeTypes|SoapOption.XsdString|SoapOption.EmbedAll,");
  4853.                 }
  4854.                
  4855.                 // Need namespace for clr type because proxy dll might have a different name than server dll
  4856.                 sb.Append("XmlNamespace=");
  4857.                 sb.Append(WsdlParser.IsValidUrl(UrlNS));
  4858.                 sb.Append(", XmlTypeNamespace=");
  4859.                 sb.Append(WsdlParser.IsValidUrl(UrlNS));
  4860.                
  4861.                 sb.Append(")]");
  4862.                 textWriter.WriteLine(sb);
  4863.                
  4864.                
  4865.                 // Print type
  4866.                 sb.Length = 0;
  4867.                 sb.Append(indentation);
  4868.                
  4869.                 // Handle Enum case
  4870.                 if (IsEnum)
  4871.                     sb.Append("public enum ");
  4872.                 else
  4873.                     sb.Append("public class ");
  4874.                
  4875.                 if (_bNestedType)
  4876.                     sb.Append(WsdlParser.IsValidCS(NestedTypeName));
  4877.                 else
  4878.                     sb.Append(WsdlParser.IsValidCS(Name));
  4879.                 if (_baseType != null) {
  4880.                     sb.Append(" : ");
  4881.                     sb.Append(WsdlParser.IsValidCSAttr(_baseType.GetName(curNS)));
  4882.                 }
  4883.                 else if (IsEnum && _enumType != null && _enumType.Length > 0) {
  4884.                     sb.Append(" : ");
  4885.                     sb.Append(WsdlParser.IsValidCSAttr(_enumType));
  4886.                 }
  4887.                
  4888.                 textWriter.WriteLine(sb);
  4889.                
  4890.                 textWriter.Write(indentation);
  4891.                 textWriter.WriteLine('{');
  4892.                
  4893.                 string newIndentation = indentation + " ";
  4894.                 for (int i = 0; i < _facets.Count; i++) {
  4895.                     Util.Log("URTSimpleType.PrintCSC Invoke _facets PrintCSC ");
  4896.                     ((SchemaFacet)_facets[i]).PrintCSC(textWriter, newIndentation, curNS, sb);
  4897.                 }
  4898.                
  4899.                 textWriter.Write(indentation);
  4900.                 textWriter.WriteLine('}');
  4901.                 return;
  4902.             }
  4903.            
  4904.             internal override MethodFlags GetMethodFlags(URTMethod method)
  4905.             {
  4906.                 Debug.Assert(false, "GetMethodFlags called on a SimpleSchemaType");
  4907.                 return (0);
  4908.             }
  4909.            
  4910.             private string _baseTypeName;
  4911.             private string _baseTypeXmlNS;
  4912.             private BaseType _baseType;
  4913.             private string _fieldString;
  4914.             private bool _bEnum;
  4915.             private bool _bAnonymous;
  4916.             private string _encoding;
  4917.             private ArrayList _facets;
  4918.             private string _enumType;
  4919.             private WsdlParser _parser;
  4920.         }
  4921.        
  4922.         // Represents a complex type
  4923.         internal class URTComplexType : BaseType
  4924.         {
  4925.             internal URTComplexType(string name, string urlNS, string ns, string encodedNS, SchemaBlockType blockDefault, bool bSUDSType, bool bAnonymous, WsdlParser parser, URTNamespace xns) : base(name, urlNS, ns, encodedNS)
  4926.             {
  4927.                 Util.Log("URTComplexType.URTComplexType name " + this.GetHashCode() + " " + name + " urlNS " + urlNS + " ns " + ns + " encodedNS " + encodedNS + " bSUDStype " + bSUDSType + " bAnonymous " + bAnonymous);
  4928.                 _baseTypeName = null;
  4929.                 _baseTypeXmlNS = null;
  4930.                 _baseType = null;
  4931.                 _connectURLs = null;
  4932.                 _bStruct = !bSUDSType;
  4933.                 _blockType = blockDefault;
  4934.                 _bSUDSType = bSUDSType;
  4935.                 _bAnonymous = bAnonymous;
  4936.                 Debug.Assert(bAnonymous == false || _bSUDSType == false);
  4937.                 _fieldString = null;
  4938.                 _fields = new ArrayList();
  4939.                 _methods = new ArrayList();
  4940.                 _implIFaces = new ArrayList();
  4941.                 _implIFaceNames = new ArrayList();
  4942.                 _sudsType = SUDSType.None;
  4943.                 _parser = parser;
  4944.                
  4945.                 int index = name.IndexOf('+');
  4946.                 if (index > 0) {
  4947.                     // Nested type see if outer type has been added to namespace
  4948.                     string outerType = parser.Atomize(name.Substring(0, index));
  4949.                     URTComplexType cs = xns.LookupComplexType(outerType);
  4950.                     if (cs == null) {
  4951.                         URTComplexType newCs = new URTComplexType(outerType, urlNS, ns, encodedNS, blockDefault, bSUDSType, bAnonymous, parser, xns);
  4952.                         Util.Log("URTComplexType.URTComplexType add outerType to namespace " + outerType + " nestedname " + name);
  4953.                         xns.AddComplexType(newCs);
  4954.                     }
  4955.                 }
  4956.                
  4957.                
  4958.                 if (xns.UrtType == UrtType.Interop) {
  4959.                     // Interop class names can have '.', replace these with '_', and set wire name to original type name.
  4960.                     index = name.LastIndexOf('.');
  4961.                     if (index > -1) {
  4962.                         // class names can't have '.' so replace with '$'. Use xmlType attribute to send original name on wire.
  4963.                         _wireType = name;
  4964.                         Name = name.Replace(".", "_");
  4965.                         SearchName = name;
  4966.                     }
  4967.                 }
  4968.                
  4969.             }
  4970.            
  4971.             internal void AddNestedType(BaseType ct)
  4972.             {
  4973.                 if (_nestedTypes == null)
  4974.                     _nestedTypes = new ArrayList(10);
  4975.                
  4976.                 _nestedTypes.Add(ct);
  4977.             }
  4978.            
  4979.             internal void Extends(string baseTypeName, string baseTypeNS)
  4980.             {
  4981.                 Util.Log("URTComplexType.Extends baseTypeName " + baseTypeName + " baseTypeNS " + baseTypeNS);
  4982.                 _baseTypeName = baseTypeName;
  4983.                 _baseTypeXmlNS = baseTypeNS;
  4984.             }
  4985.             internal void Implements(string iFaceName, string iFaceNS, WsdlParser parser)
  4986.             {
  4987.                 Util.Log("URTComplexType.Implements IFaceName " + iFaceName + " iFaceNS " + iFaceNS);
  4988.                 _implIFaceNames.Add(iFaceName);
  4989.                 _implIFaceNames.Add(iFaceNS);
  4990.                 // Urt namespace will not have schema, they need to be recorded.
  4991.                 URTNamespace parsingNamespace = parser.AddNewNamespace(iFaceNS);
  4992.                 /*
  4993.                 if (parsingNamespace == null)
  4994.                 {
  4995.                     parsingNamespace = new URTNamespace(iFaceNS, parser);
  4996.                 }
  4997.                 */               
  4998.                
  4999. URTInterface parsingInterface = parsingNamespace.LookupInterface(iFaceName);
  5000.                 if (parsingInterface == null) {
  5001.                     parsingInterface = new URTInterface(iFaceName, parsingNamespace.Name, parsingNamespace.Namespace, parsingNamespace.EncodedNS, _parser);
  5002.                     parsingNamespace.AddInterface(parsingInterface);
  5003.                 }
  5004.             }
  5005.            
  5006.             internal ArrayList ConnectURLs {
  5007.                 set { _connectURLs = value; }
  5008.             }
  5009.             internal bool IsStruct {
  5010.                 set { _bStruct = value; }
  5011.             }
  5012.             internal bool IsSUDSType {
  5013.                 get { return (_bSUDSType); }
  5014.                 set {
  5015.                     _bSUDSType = value;
  5016.                     _bStruct = !value;
  5017.                 }
  5018.             }
  5019.             internal SUDSType SUDSType {
  5020.                 get { return (_sudsType); }
  5021.                 set { _sudsType = value; }
  5022.             }
  5023.             internal SudsUse SudsUse {
  5024.                 get { return (_sudsUse); }
  5025.                 set { _sudsUse = value; }
  5026.             }
  5027.            
  5028.             internal bool IsValueType {
  5029.                 set { _bValueType = value; }
  5030.             }
  5031.            
  5032.             internal SchemaBlockType BlockType {
  5033.                 set { _blockType = value; }
  5034.             }
  5035.            
  5036.             internal string WireType {
  5037.                 get { return (_wireType); }
  5038.             }
  5039.            
  5040.             internal ArrayList Inherit {
  5041.                 get { return (_inherit); }
  5042.                 set { _inherit = value; }
  5043.             }
  5044.            
  5045.             internal bool IsArray()
  5046.             {
  5047.                 Util.Log("URTComplexType.IsArray " + this.GetHashCode() + " " + Name + " IsArray " + _arrayType);
  5048.                 if (_arrayType != null)
  5049.                     return true;
  5050.                 else
  5051.                     return false;
  5052.             }
  5053.             internal string GetArray()
  5054.             {
  5055.                 return _clrarray;
  5056.             }
  5057.             internal URTNamespace GetArrayNS()
  5058.             {
  5059.                 return _arrayNS;
  5060.             }
  5061.            
  5062.             internal string GetClassName()
  5063.             {
  5064.                 string cname = null;
  5065.                 if (_bNameMethodConflict)
  5066.                     cname = "C" + Name;
  5067.                 else
  5068.                     // Class name generated from a non-Suds wsdl and a method name and portType conflicted.
  5069.                     cname = Name;
  5070.                 return cname;
  5071.             }
  5072.            
  5073.             internal bool IsPrint {
  5074.                 get { return _bprint; }
  5075.                 set { _bprint = value; }
  5076.             }
  5077.            
  5078.             internal override bool IsEmittableFieldType {
  5079.                 get {
  5080.                     Util.Log("URTComplexType.IsEmittableFieldType _fieldString " + _fieldString + " _bAnonymous " + _bAnonymous + " _fields.Count " + _fields.Count);
  5081.                     if (_fieldString == null) {
  5082.                         if ((_bAnonymous == true) && (_fields.Count == 1)) {
  5083.                             URTField field = (URTField)_fields[0];
  5084.                             if (field.IsArray) {
  5085.                                 _fieldString = field.TypeName;
  5086.                                 return (true);
  5087.                             }
  5088.                         }
  5089.                         _fieldString = String.Empty;
  5090.                     }
  5091.                    
  5092.                     return (_fieldString != String.Empty);
  5093.                 }
  5094.             }
  5095.             internal override string FieldName {
  5096.                 get { return (_fieldString); }
  5097.             }
  5098.             internal override string FieldNamespace {
  5099.                 get { return (((URTField)_fields[0]).TypeNS); }
  5100.             }
  5101.             internal override bool PrimitiveField {
  5102.                 get { return ((((URTField)_fields[0]).IsPrimitive)); }
  5103.             }
  5104.             internal override string GetName(string curNS)
  5105.             {
  5106.                 if ((_fieldString != null) && (_fieldString != String.Empty))
  5107.                     return (_fieldString);
  5108.                
  5109.                 return (base.GetName(curNS));
  5110.             }
  5111.             internal ArrayList Fields {
  5112.                 get { return _fields; }
  5113.             }
  5114.            
  5115.             internal void AddField(URTField field)
  5116.             {
  5117.                 Util.Log("URTComplexType.AddField");
  5118.                 _fields.Add(field);
  5119.             }
  5120.             internal void AddMethod(URTMethod method)
  5121.             {
  5122.                 Util.Log("URTComplexType.AddMethod " + method);
  5123.                 if (method.Name == Name) {
  5124.                     // Type generated from an non-suds wsdl. Append the class name with a C when printing.
  5125.                     _bNameMethodConflict = true;
  5126.                 }
  5127.                 _methods.Add(method);
  5128.                 int index = method.Name.IndexOf('.');
  5129.                 if (index > 0)
  5130.                     method.MethodFlags = MethodFlags.None;
  5131.                 else
  5132.                     //interface qualfied method names have no method modifier
  5133.                     method.MethodFlags = method.MethodFlags |= MethodFlags.Public;
  5134.                 // method names are public for this version of wsdl
  5135.             }
  5136.             private URTMethod GetMethod(string name)
  5137.             {
  5138.                 Util.Log("URTComplexType.GetMethod " + name + " count " + _methods.Count + " Name " + Name + " base ns " + _baseTypeXmlNS + " base name " + _baseTypeName);
  5139.                 for (int i = 0; i < _methods.Count; i++) {
  5140.                     URTMethod method = (URTMethod)_methods[i];
  5141.                     Util.Log("URTComplexType.GetMethod interate " + method.Name);
  5142.                     if (method.Name == name)
  5143.                         return (method);
  5144.                 }
  5145.                
  5146.                 return (null);
  5147.             }
  5148.             internal void ResolveTypes(WsdlParser parser)
  5149.             {
  5150.                 Util.Log("URTComplexType.ResolveTypes " + Name + " _baseTypeName " + _baseTypeName + " IsSUDSType " + IsSUDSType);
  5151.                 string baseTypeNS = null;
  5152.                 string baseTypeAssemName = null;
  5153.                 if (IsArray()) {
  5154.                     ResolveArray();
  5155.                     return;
  5156.                 }
  5157.                
  5158.                 if (IsSUDSType) {
  5159.                     // BaseType == null;
  5160.                     if (_sudsType == SUDSType.None) {
  5161.                         if (_parser._bWrappedProxy)
  5162.                             _sudsType = SUDSType.ClientProxy;
  5163.                         else
  5164.                             _sudsType = SUDSType.MarshalByRef;
  5165.                     }
  5166.                 }
  5167.                
  5168.                 if (_baseTypeName != null) {
  5169.                     Util.Log("URTComplexType.ResolveTypes 1 ");
  5170.                     UrtType urtType = parser.IsURTExportedType(_baseTypeXmlNS, out baseTypeNS, out baseTypeAssemName);
  5171.                     if (urtType == UrtType.UrtSystem || baseTypeNS.StartsWith("System", StringComparison.Ordinal)) {
  5172.                         _baseType = new SystemType(_baseTypeName, _baseTypeXmlNS, baseTypeNS, baseTypeAssemName);
  5173.                     }
  5174.                     else {
  5175.                         URTNamespace ns = parser.LookupNamespace(_baseTypeXmlNS);
  5176.                         if (ns == null) {
  5177.                             throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), _baseTypeXmlNS, _baseTypeName));
  5178.                         }
  5179.                         _baseType = ns.LookupComplexType(_baseTypeName);
  5180.                         if (_baseType == null) {
  5181.                             _baseType = new SystemType(_baseTypeName, _baseTypeXmlNS, baseTypeNS, baseTypeAssemName);
  5182.                            
  5183.                             /*
  5184.                             throw new SUDSParserException(
  5185.                                                         String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"),
  5186.                                                                       _baseTypeName, _baseTypeXmlNS));
  5187.                                                                       */                           
  5188.                         }
  5189.                     }
  5190.                 }
  5191.                 // Top of inheritance hiearchy for a Wrapped proxy is RemotingClientProxy
  5192.                 if (IsSUDSType) {
  5193.                     if (_parser._bWrappedProxy) {
  5194.                        
  5195.                         if (_baseTypeName == null || _baseType is SystemType) {
  5196.                             _baseTypeName = "RemotingClientProxy";
  5197.                             _baseTypeXmlNS = SoapServices.CodeXmlNamespaceForClrTypeNamespace("System.Runtime.Remoting", "System.Runtime.Remoting");
  5198.                             baseTypeNS = "System.Runtime.Remoting.Services";
  5199.                             baseTypeAssemName = "System.Runtime.Remoting";
  5200.                             _baseType = new SystemType(_baseTypeName, _baseTypeXmlNS, baseTypeNS, baseTypeAssemName);
  5201.                         }
  5202.                     }
  5203.                     else if (_baseTypeName == null) {
  5204.                         _baseTypeName = "MarshalByRefObject";
  5205.                         _baseTypeXmlNS = SoapServices.CodeXmlNamespaceForClrTypeNamespace("System", null);
  5206.                         baseTypeNS = "System";
  5207.                         baseTypeAssemName = null;
  5208.                         _baseType = new SystemType(_baseTypeName, _baseTypeXmlNS, baseTypeNS, baseTypeAssemName);
  5209.                     }
  5210.                 }
  5211.                 else if (_baseType == null) {
  5212.                     Util.Log("URTComplexType.ResolveTypes 5 ");
  5213.                     _baseType = new SystemType("Object", SoapServices.CodeXmlNamespaceForClrTypeNamespace("System", null), "System", null);
  5214.                 }
  5215.                 for (int i = 0; i < _implIFaceNames.Count; i = i + 2) {
  5216.                     string implIFaceName = (string)_implIFaceNames[i];
  5217.                     string implIFaceXmlNS = (string)_implIFaceNames[i + 1];
  5218.                     string implIFaceNS;
  5219.                     string implIFaceAssemName;
  5220.                     BaseInterface iFace;
  5221.                    
  5222.                    
  5223.                     UrtType iType = parser.IsURTExportedType(implIFaceXmlNS, out implIFaceNS, out implIFaceAssemName);
  5224.                    
  5225.                     // && implIFaceNS.StartsWith("System", StringComparison.Ordinal))
  5226.                     if (iType == UrtType.UrtSystem) {
  5227.                         iFace = new SystemInterface(implIFaceName, implIFaceXmlNS, implIFaceNS, parser, implIFaceAssemName);
  5228.                     }
  5229.                     else {
  5230.                         URTNamespace ns = parser.LookupNamespace(implIFaceXmlNS);
  5231.                         if (ns == null) {
  5232.                             throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), implIFaceXmlNS, implIFaceName));
  5233.                         }
  5234.                         iFace = ns.LookupInterface(implIFaceName);
  5235.                         if (iFace == null) {
  5236.                             throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), implIFaceName, implIFaceXmlNS));
  5237.                         }
  5238.                     }
  5239.                     _implIFaces.Add(iFace);
  5240.                 }
  5241.                 for (int i = 0; i < _methods.Count; i++)
  5242.                     ((URTMethod)_methods[i]).ResolveTypes(parser);
  5243.             }
  5244.             internal void ResolveMethods()
  5245.             {
  5246.                 Util.Log("URTComplexType.ResolveMethods " + Name);
  5247.                 for (int i = 0; i < _methods.Count; i++) {
  5248.                     URTMethod method = (URTMethod)_methods[i];
  5249.                     /*
  5250.                     if (method.MethodFlags == 0)
  5251.                         method.MethodFlags = _baseType.GetMethodFlags(method);
  5252.                         */                   
  5253.                 }
  5254.                
  5255.                 return;
  5256.             }
  5257.             internal override MethodFlags GetMethodFlags(URTMethod method)
  5258.             {
  5259.                 /*
  5260.                 Debug.Assert(method.MethodFlags == 0, "Method has already been considered");
  5261.                 MethodFlags methodFlags = _baseType.GetMethodFlags(method);
  5262.                 for (int i=0;i<_methods.Count;i++)
  5263.                 {
  5264.                     URTMethod thisMethod = (URTMethod) _methods[i];
  5265.                     if (thisMethod.Equals(method))
  5266.                         thisMethod.MethodFlags = method.MethodFlags;
  5267.                 }
  5268.                 */               
  5269.                
  5270. return (method.MethodFlags);
  5271.             }
  5272.            
  5273.             internal void PrintCSC(TextWriter textWriter, string indentation, string curNS, StringBuilder sb)
  5274.             {
  5275.                 Util.Log("URTComplexType.PrintCSC enter name " + Name + " curNS " + curNS + " sudsUse " + ((Enum)_sudsUse).ToString() + " bNestedType " + bNestedType + " bNestedTypePrint " + bNestedTypePrint);
  5276.                 // Print only if the type is not an emittable field type
  5277.                 if (IsEmittableFieldType == true)
  5278.                     return;
  5279.                
  5280.                 if (bNestedType && !bNestedTypePrint)
  5281.                     return;
  5282.                
  5283.                 // Handle delegate case
  5284.                 sb.Length = 0;
  5285.                 sb.Append(indentation);
  5286.                 if (_baseTypeName != null) {
  5287.                     string baseName = _baseType.GetName(curNS);
  5288.                     if ((baseName == "System.Delegate") || (baseName == "System.MulticastDelegate")) {
  5289.                         sb.Append("public delegate ");
  5290.                         URTMethod invokeMethod = GetMethod("Invoke");
  5291.                         if (invokeMethod == null) {
  5292.                             throw new SUDSParserException(CoreChannel.GetResourceString("Remoting_Suds_DelegateWithoutInvoke"));
  5293.                         }
  5294.                         string typeString = invokeMethod.GetTypeString(curNS, true);
  5295.                         sb.Append(WsdlParser.IsValidCSAttr(typeString));
  5296.                         sb.Append(' ');
  5297.                        
  5298.                         string printName = Name;
  5299.                         int index = printName.IndexOf('.');
  5300.                         if (index > 0) {
  5301.                             printName = printName.Substring(index + 1);
  5302.                         }
  5303.                         sb.Append(WsdlParser.IsValidCS(printName));
  5304.                         sb.Append('(');
  5305.                         invokeMethod.PrintSignature(sb, curNS);
  5306.                         sb.Append(");");
  5307.                         textWriter.WriteLine(sb);
  5308.                         return;
  5309.                     }
  5310.                 }
  5311.                
  5312.                 bool bURTType = IsURTType;
  5313.                
  5314.                
  5315.                 sb.Length = 0;
  5316.                 sb.Append("\n");
  5317.                 sb.Append(indentation);
  5318.                 sb.Append("[");
  5319.                 if (_sudsType != SUDSType.ClientProxy)
  5320.                     sb.Append("Serializable, ");
  5321.                 sb.Append("SoapType(");
  5322.                
  5323.                 if (_parser._xsdVersion == XsdVersion.V1999) {
  5324.                     sb.Append("SoapOptions=SoapOption.Option1|SoapOption.AlwaysIncludeTypes|SoapOption.XsdString|SoapOption.EmbedAll,");
  5325.                 }
  5326.                 else if (_parser._xsdVersion == XsdVersion.V2000) {
  5327.                     sb.Append("SoapOptions=SoapOption.Option2|SoapOption.AlwaysIncludeTypes|SoapOption.XsdString|SoapOption.EmbedAll,");
  5328.                 }
  5329.                
  5330.                 if (!bURTType) {
  5331.                     sb.Append("XmlElementName=");
  5332.                     sb.Append(WsdlParser.IsValidUrl(GetClassName()));
  5333.                     sb.Append(", XmlNamespace=");
  5334.                     sb.Append(WsdlParser.IsValidUrl(Namespace));
  5335.                     sb.Append(", XmlTypeName=");
  5336.                     if (WireType != null)
  5337.                         sb.Append(WsdlParser.IsValidUrl(WireType));
  5338.                     else
  5339.                         sb.Append(WsdlParser.IsValidUrl(GetClassName()));
  5340.                     sb.Append(", XmlTypeNamespace=");
  5341.                     sb.Append(WsdlParser.IsValidUrl(Namespace));
  5342.                 }
  5343.                 else {
  5344.                     // Need namespace for clr type because proxy dll might have a different name than server dll
  5345.                     sb.Append("XmlNamespace=");
  5346.                     sb.Append(WsdlParser.IsValidUrl(UrlNS));
  5347.                     sb.Append(", XmlTypeNamespace=");
  5348.                     sb.Append(WsdlParser.IsValidUrl(UrlNS));
  5349.                     if (WireType != null) {
  5350.                         sb.Append(", XmlTypeName=");
  5351.                         sb.Append(WsdlParser.IsValidUrl(WireType));
  5352.                     }
  5353.                 }
  5354.                
  5355.                 sb.Append(")]");
  5356.                 sb.Append("[ComVisible(true)]");
  5357.                 textWriter.WriteLine(sb);
  5358.                
  5359.                 sb.Length = 0;
  5360.                 sb.Append(indentation);
  5361.                
  5362.                 if (_sudsUse == SudsUse.Struct)
  5363.                     sb.Append("public struct ");
  5364.                 else
  5365.                     sb.Append("public class ");
  5366.                 if (_bNestedType)
  5367.                     sb.Append(WsdlParser.IsValidCS(NestedTypeName));
  5368.                 else
  5369.                     sb.Append(WsdlParser.IsValidCS(GetClassName()));
  5370.                
  5371.                 if (_baseTypeName != null || _sudsUse == SudsUse.ISerializable || _implIFaces.Count > 0)
  5372.                     sb.Append(" : ");
  5373.                 bool bBaseIsURTType = true;
  5374.                 string baseString = null;
  5375.                
  5376.                 bool binherit = false;
  5377.                 bool fClientProxy;
  5378.                 if (_baseTypeName == "RemotingClientProxy")
  5379.                     fClientProxy = true;
  5380.                 else
  5381.                     fClientProxy = false;
  5382.                
  5383.                 if (fClientProxy) {
  5384.                     sb.Append("System.Runtime.Remoting.Services.RemotingClientProxy");
  5385.                     binherit = true;
  5386.                 }
  5387.                 else if (_baseTypeName != null) {
  5388.                     bBaseIsURTType = _baseType.IsURTType;
  5389.                     baseString = _baseType.GetName(curNS);
  5390.                     if (baseString == "System.__ComObject") {
  5391.                         /*textWriter.Write(indentation);
  5392.                         textWriter.WriteLine("[guid(\"cc3bf020-1881-4e44-88d8-39b1052b1b11\")]");
  5393.                         textWriter.Write(indentation);
  5394.                         textWriter.WriteLine("[comimport]"); */                       
  5395. sb.Append("System.MarshalByRefObject");
  5396.                         binherit = true;
  5397.                     }
  5398.                     else {
  5399.                         sb.Append(WsdlParser.IsValidCSAttr(baseString));
  5400.                         binherit = true;
  5401.                     }
  5402.                 }
  5403.                 else {
  5404.                     // no base name
  5405.                     if (_sudsUse == SudsUse.ISerializable) {
  5406.                         sb.Append("System.Runtime.Serialization.ISerializable");
  5407.                         binherit = true;
  5408.                     }
  5409.                 }
  5410.                
  5411.                 if (_implIFaces.Count > 0) {
  5412.                     for (int i = 0; i < _implIFaces.Count; i++) {
  5413.                         if (binherit)
  5414.                             sb.Append(", ");
  5415.                         sb.Append(WsdlParser.IsValidCS(((BaseInterface)_implIFaces[i]).GetName(curNS)));
  5416.                         binherit = true;
  5417.                     }
  5418.                 }
  5419.                
  5420.                
  5421.                 textWriter.WriteLine(sb);
  5422.                
  5423.                 textWriter.Write(indentation);
  5424.                 textWriter.WriteLine('{');
  5425.                
  5426.                 string newIndentation = indentation + " ";
  5427.                 int newIndentationLength = newIndentation.Length;
  5428.                 //bool fClientProxy = _connectURL != null;
  5429.                
  5430.                 Util.Log("URTComplexType.PrintCSC _sudsType " + ((Enum)_sudsType).ToString());
  5431.                
  5432.                 if (fClientProxy) {
  5433.                     PrintClientProxy(textWriter, indentation, curNS, sb);
  5434.                 }
  5435.                
  5436.                 if (_methods.Count > 0) {
  5437.                     //textWriter.Write(newIndentation);
  5438.                     //textWriter.WriteLine("// Class Methods");
  5439.                     string bodyPrefix = null;
  5440.                    
  5441.                     if (_parser._bWrappedProxy) {
  5442.                         sb.Length = 0;
  5443.                         sb.Append("((");
  5444.                         sb.Append(WsdlParser.IsValidCS(GetClassName()));
  5445.                         sb.Append(") _tp).");
  5446.                         bodyPrefix = sb.ToString();
  5447.                     }
  5448.                    
  5449.                     for (int i = 0; i < _methods.Count; i++) {
  5450.                         Util.Log("URTComplexType.PrintCSC Invoke methods class methods PrintCSC class " + Name + " methodName " + ((URTMethod)_methods[i]).Name);
  5451.                         ((URTMethod)_methods[i]).PrintCSC(textWriter, newIndentation, " ", curNS, MethodPrintEnum.PrintBody, bURTType, bodyPrefix, sb);
  5452.                     }
  5453.                     textWriter.WriteLine();
  5454.                 }
  5455.                
  5456.                
  5457.                 /*
  5458.                 if (_implIFaces.Count > 0)
  5459.                 {
  5460.                     ArrayList printedIFaces = new ArrayList(_implIFaces.Count);
  5461.                     for (int i=0;i<_implIFaces.Count;i++)
  5462.                         ((BaseInterface) _implIFaces[i]).PrintClassMethods(textWriter, newIndentation, curNS, printedIFaces, fClientProxy, sb);
  5463.                     textWriter.WriteLine();
  5464.                 }
  5465.                 */               
  5466.                
  5467.                 // Standard class
  5468. if (_fields.Count > 0) {
  5469.                     textWriter.Write(newIndentation);
  5470.                     textWriter.WriteLine("// Class Fields");
  5471.                     for (int i = 0; i < _fields.Count; i++) {
  5472.                         Util.Log("URTComplexType.PrintCS Invoke _fields PrintCSC");
  5473.                         ((URTField)_fields[i]).PrintCSC(textWriter, newIndentation, curNS, sb);
  5474.                     }
  5475.                 }
  5476.                
  5477.                 // print nested types
  5478.                 if (_nestedTypes != null && _nestedTypes.Count > 0) {
  5479.                     foreach (BaseType ctype in _nestedTypes) {
  5480.                         ctype.bNestedTypePrint = true;
  5481.                         if (ctype is URTSimpleType)
  5482.                             ((URTSimpleType)ctype).PrintCSC(textWriter, newIndentation, curNS, sb);
  5483.                         else
  5484.                             ((URTComplexType)ctype).PrintCSC(textWriter, newIndentation, curNS, sb);
  5485.                        
  5486.                         ctype.bNestedTypePrint = false;
  5487.                     }
  5488.                 }
  5489.                
  5490.                 if (_sudsUse == SudsUse.ISerializable)
  5491.                     PrintISerializable(textWriter, indentation, curNS, sb, baseString);
  5492.                
  5493.                 // Close class
  5494.                 sb.Length = 0;
  5495.                 sb.Append(indentation);
  5496.                 sb.Append("}");
  5497.                 textWriter.WriteLine(sb);
  5498.                 Util.Log("URTComplexType.PrintCSC Exit name " + Name + " curNS " + curNS);
  5499.                 return;
  5500.             }
  5501.            
  5502.             private void PrintClientProxy(TextWriter textWriter, string indentation, string curNS, StringBuilder sb)
  5503.             {
  5504.                 Util.Log("URTComplexType.PrintCSC PrintClientProxy ");
  5505.                 string indent1 = indentation + " ";
  5506.                 string indent2 = indent1 + " ";
  5507.                 sb.Length = 0;
  5508.                 sb.Append(indent1);
  5509.                 sb.Append("// Constructor");
  5510.                 textWriter.WriteLine(sb);
  5511.                
  5512.                 sb.Length = 0;
  5513.                 sb.Append(indent1);
  5514.                 sb.Append("public ");
  5515.                 sb.Append(WsdlParser.IsValidCS(GetClassName()));
  5516.                 sb.Append("()");
  5517.                 textWriter.WriteLine(sb);
  5518.                
  5519.                 sb.Length = 0;
  5520.                 sb.Append(indent1);
  5521.                 sb.Append('{');
  5522.                 textWriter.WriteLine(sb);
  5523.                
  5524.                 if (_connectURLs != null) {
  5525.                     for (int i = 0; i < _connectURLs.Count; i++) {
  5526.                         sb.Length = 0;
  5527.                         sb.Append(indent2);
  5528.                         if (i == 0) {
  5529.                             sb.Append("base.ConfigureProxy(this.GetType(), ");
  5530.                             sb.Append(WsdlParser.IsValidUrl((string)_connectURLs[i]));
  5531.                             sb.Append(");");
  5532.                         }
  5533.                         else {
  5534.                             // Only the first location is used, the rest are commented out in the proxy
  5535.                             sb.Append("//base.ConfigureProxy(this.GetType(), ");
  5536.                             sb.Append(WsdlParser.IsValidUrl((string)_connectURLs[i]));
  5537.                             sb.Append(");");
  5538.                         }
  5539.                         textWriter.WriteLine(sb);
  5540.                     }
  5541.                 }
  5542.                
  5543.                
  5544.                
  5545.                 //Preload classes
  5546.                 foreach (URTNamespace ns in _parser._URTNamespaces) {
  5547.                     foreach (URTComplexType cs in ns._URTComplexTypes) {
  5548.                         if ((cs._sudsType != SUDSType.ClientProxy) && !cs.IsArray()) {
  5549.                             sb.Length = 0;
  5550.                             sb.Append(indent2);
  5551.                             sb.Append("System.Runtime.Remoting.SoapServices.PreLoad(typeof(");
  5552.                             sb.Append(WsdlParser.IsValidCS(ns.EncodedNS));
  5553.                             if (ns.EncodedNS != null && ns.EncodedNS.Length > 0)
  5554.                                 sb.Append(".");
  5555.                             sb.Append(WsdlParser.IsValidCS(cs.Name));
  5556.                             sb.Append("));");
  5557.                             textWriter.WriteLine(sb);
  5558.                         }
  5559.                     }
  5560.                 }
  5561.                
  5562.                 foreach (URTNamespace ns in _parser._URTNamespaces) {
  5563.                     foreach (URTSimpleType ss in ns._URTSimpleTypes) {
  5564.                         if (ss.IsEnum) {
  5565.                             sb.Length = 0;
  5566.                             sb.Append(indent2);
  5567.                             sb.Append("System.Runtime.Remoting.SoapServices.PreLoad(typeof(");
  5568.                             sb.Append(WsdlParser.IsValidCS(ns.EncodedNS));
  5569.                             if (ns.EncodedNS != null && ns.EncodedNS.Length > 0)
  5570.                                 sb.Append(".");
  5571.                             sb.Append(WsdlParser.IsValidCS(ss.Name));
  5572.                             sb.Append("));");
  5573.                             textWriter.WriteLine(sb);
  5574.                         }
  5575.                     }
  5576.                 }
  5577.                
  5578.                 sb.Length = 0;
  5579.                 sb.Append(indent1);
  5580.                 sb.Append('}');
  5581.                 textWriter.WriteLine(sb);
  5582.                
  5583.                 // Base class for Client Proxy
  5584.                 // Write Property to retrieve Transparent Proxy
  5585.                
  5586.                 textWriter.WriteLine();
  5587.                
  5588.                 sb.Length = 0;
  5589.                 sb.Append(indent1);
  5590.                 sb.Append("public Object RemotingReference");
  5591.                 textWriter.WriteLine(sb);
  5592.                
  5593.                 sb.Length = 0;
  5594.                 sb.Append(indent1);
  5595.                 sb.Append("{");
  5596.                 textWriter.WriteLine(sb);
  5597.                
  5598.                 sb.Length = 0;
  5599.                 sb.Append(indent2);
  5600.                 sb.Append("get{return(_tp);}");
  5601.                 textWriter.WriteLine(sb);
  5602.                
  5603.                 sb.Length = 0;
  5604.                 sb.Append(indent1);
  5605.                 sb.Append("}");
  5606.                 textWriter.WriteLine(sb);
  5607.                
  5608.                 textWriter.WriteLine();
  5609.             }
  5610.            
  5611.             private void PrintISerializable(TextWriter textWriter, string indentation, string curNS, StringBuilder sb, string baseString)
  5612.             {
  5613.                 Util.Log("URTComplexType.PrintCSC PrintISerializable ");
  5614.                 string indent1 = indentation + " ";
  5615.                 string indent2 = indent1 + " ";
  5616.                
  5617.                 if (baseString == null || baseString.StartsWith("System.", StringComparison.Ordinal)) {
  5618.                     // Don't generate if base class already contains field
  5619.                     sb.Length = 0;
  5620.                     sb.Append(indent1);
  5621.                     sb.Append("public System.Runtime.Serialization.SerializationInfo info;");
  5622.                     textWriter.WriteLine(sb);
  5623.                    
  5624.                     sb.Length = 0;
  5625.                     sb.Append(indent1);
  5626.                     sb.Append("public System.Runtime.Serialization.StreamingContext context; \n");
  5627.                     textWriter.WriteLine(sb);
  5628.                 }
  5629.                
  5630.                 sb.Length = 0;
  5631.                 sb.Append(indent1);
  5632.                
  5633.                 if (_baseTypeName == null)
  5634.                     sb.Append("public ");
  5635.                 else
  5636.                     sb.Append("protected ");
  5637.                
  5638.                 if (_bNestedType)
  5639.                     sb.Append(WsdlParser.IsValidCS(NestedTypeName));
  5640.                 else
  5641.                     sb.Append(WsdlParser.IsValidCS(GetClassName()));
  5642.                
  5643.                 sb.Append("(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)");
  5644.                
  5645.                 if (_baseTypeName != null)
  5646.                     sb.Append(" : base(info, context)");
  5647.                 textWriter.WriteLine(sb);
  5648.                
  5649.                 sb.Length = 0;
  5650.                 sb.Append(indent1);
  5651.                 sb.Append("{");
  5652.                 textWriter.WriteLine(sb);
  5653.                
  5654.                 if (baseString == null || baseString.StartsWith("System.", StringComparison.Ordinal)) {
  5655.                     // Don't generate if base class already contains field
  5656.                     sb.Length = 0;
  5657.                     sb.Append(indent2);
  5658.                     sb.Append("this.info = info;");
  5659.                     textWriter.WriteLine(sb);
  5660.                    
  5661.                     sb.Length = 0;
  5662.                     sb.Append(indent2);
  5663.                     sb.Append("this.context = context;");
  5664.                     textWriter.WriteLine(sb);
  5665.                 }
  5666.                
  5667.                
  5668.                 sb.Length = 0;
  5669.                 sb.Append(indent1);
  5670.                 sb.Append("}");
  5671.                 textWriter.WriteLine(sb);
  5672.                
  5673.                 if (_baseTypeName == null) {
  5674.                     sb.Length = 0;
  5675.                     sb.Append(indent1);
  5676.                     sb.Append("public void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)");
  5677.                     textWriter.WriteLine(sb);
  5678.                    
  5679.                     sb.Length = 0;
  5680.                     sb.Append(indent1);
  5681.                     sb.Append("{");
  5682.                     textWriter.WriteLine(sb);
  5683.                    
  5684.                     sb.Length = 0;
  5685.                     sb.Append(indent1);
  5686.                     sb.Append("}");
  5687.                     textWriter.WriteLine(sb);
  5688.                 }
  5689.                
  5690.                
  5691.             }
  5692.            
  5693.             internal void AddArray(string arrayType, URTNamespace arrayNS)
  5694.             {
  5695.                 Util.Log("URTComplexType.ResolveArray Entry " + this.GetHashCode() + " " + _arrayType + " ns " + _arrayNS);
  5696.                 _arrayType = arrayType;
  5697.                
  5698.                 /*
  5699.                 int index = arrayType.IndexOf('+');
  5700.                 if (index > 0)
  5701.                 {
  5702.                     // Nested Type
  5703.                     String outerTypeName = arrayType.Substring(0, index);
  5704.                     String nestedTypeName = arrayType.Substring(index+1);
  5705.                     _arrayType = outerTypeName+"."+nestedTypeName;
  5706.                 }
  5707.                 */               
  5708. _arrayNS = arrayNS;
  5709.                 Util.Log("URTComplexType.AddArray " + arrayType + " ns " + (arrayNS == null ? "null" : arrayNS.Namespace) + " finalName " + _arrayType);
  5710.             }
  5711.            
  5712.             internal void ResolveArray()
  5713.             {
  5714.                 Util.Log("URTComplexType.ResolveArray Entry " + this.GetHashCode() + " " + _arrayType + " ns " + _arrayNS);
  5715.                
  5716.                 if (_clrarray != null)
  5717.                     return;
  5718.                
  5719.                 string actualElementType = null;
  5720.                 string wireElementType = _arrayType;
  5721.                 int index = _arrayType.IndexOf("[");
  5722.                 if (index < 0) {
  5723.                     throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_WsdlInvalidArraySyntax"), _arrayType));
  5724.                 }
  5725.                
  5726.                 wireElementType = _arrayType.Substring(0, index);
  5727.                
  5728.                 switch (_arrayNS.UrtType) {
  5729.                     case UrtType.Xsd:
  5730.                         actualElementType = _parser.MapSchemaTypesToCSharpTypes(wireElementType);
  5731.                         break;
  5732.                     case UrtType.UrtSystem:
  5733.                     case UrtType.UrtUser:
  5734.                         actualElementType = wireElementType;
  5735.                         break;
  5736.                     case UrtType.Interop:
  5737.                         actualElementType = wireElementType;
  5738.                         break;
  5739.                     default:
  5740.                         Debug.Assert(false, "!UrtType.None");
  5741.                         break;
  5742.                 }
  5743.                
  5744.                 _clrarray = actualElementType + FilterDimensions(_arrayType.Substring(index));
  5745.                 Util.Log("URTComplexType.ResolveArray Exit " + _clrarray + " " + _arrayNS + " elementname " + actualElementType);
  5746.             }
  5747.            
  5748.             // Need to remove dimensions in an array (some wsdl's generate fixed arrays with dimensions)
  5749.             private string FilterDimensions(string value)
  5750.             {
  5751.                 char[] outChar = new char[value.Length];
  5752.                 for (int i = 0; i < value.Length; i++) {
  5753.                     if (Char.IsDigit(value[i]))
  5754.                         outChar[i] = ' ';
  5755.                     else
  5756.                         outChar[i] = value[i];
  5757.                 }
  5758.                 return new string(outChar);
  5759.             }
  5760.            
  5761.            
  5762.             private string _baseTypeName;
  5763.             private string _baseTypeXmlNS;
  5764.             private BaseType _baseType;
  5765.             private ArrayList _connectURLs;
  5766.             private bool _bStruct;
  5767.             private SchemaBlockType _blockType;
  5768.             private bool _bSUDSType;
  5769.             private bool _bAnonymous;
  5770.             private string _wireType;
  5771.             private ArrayList _inherit;
  5772.             // proxy hierarchy
  5773.             private string _fieldString;
  5774.             private ArrayList _implIFaceNames;
  5775.             private ArrayList _implIFaces;
  5776.             private ArrayList _fields;
  5777.             private ArrayList _methods;
  5778.             private SUDSType _sudsType;
  5779.             private SudsUse _sudsUse;
  5780.             private bool _bValueType;
  5781.             private WsdlParser _parser;
  5782.             private string _arrayType;
  5783.             private URTNamespace _arrayNS;
  5784.             private string _clrarray;
  5785.             private bool _bprint = true;
  5786.             private bool _bNameMethodConflict = false;
  5787.            
  5788.         }
  5789.        
  5790.         // Represents an XML element declaration
  5791.         internal class ElementDecl
  5792.         {
  5793.             // Constructor
  5794.             internal ElementDecl(string elmName, string elmNS, string typeName, string typeNS, bool bPrimitive)
  5795.             {
  5796.                 Util.Log("ElementDecl.ElementDecl elmName " + elmName + " elmNS " + elmNS + " typeName " + typeName + " typeNS " + typeNS + " bPrimitive " + bPrimitive);
  5797.                 _elmName = elmName;
  5798.                 _elmNS = elmNS;
  5799.                 _typeName = typeName;
  5800.                 _typeNS = typeNS;
  5801.                 _bPrimitive = bPrimitive;
  5802.             }
  5803.            
  5804.             // Field accessors
  5805.             internal string Name {
  5806.                 get { return (_elmName); }
  5807.             }
  5808.             internal string Namespace {
  5809.                 get { return (_elmNS); }
  5810.             }
  5811.             internal string TypeName {
  5812.                 get { return (_typeName); }
  5813.             }
  5814.             internal string TypeNS {
  5815.                 get { return (_typeNS); }
  5816.             }
  5817.            
  5818.             internal bool Resolve(WsdlParser parser)
  5819.             {
  5820.                 Util.Log("ElementDecl.Resolve " + TypeName + " " + TypeNS);
  5821.                 // Return immediately for element declaration of primitive types
  5822.                 if (_bPrimitive)
  5823.                     return true;
  5824.                
  5825.                 // Lookup the type from the element declaration
  5826.                 URTNamespace typeNS = parser.LookupNamespace(TypeNS);
  5827.                 if (typeNS == null) {
  5828.                     throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), TypeNS, TypeName));
  5829.                 }
  5830.                 BaseType type = typeNS.LookupType(TypeName);
  5831.                 if (type == null) {
  5832.                     // Because there might be multiple bindings and some not soap, there can be failures in the non soap bindings.
  5833.                     return false;
  5834.                     /*
  5835.                     throw new SUDSParserException(
  5836.                                                 String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"),
  5837.                                                               TypeName, TypeNS));
  5838.                                                               */                   
  5839.                 }
  5840.                
  5841.                 type.ElementName = Name;
  5842.                 type.ElementNS = Namespace;
  5843.                
  5844.                 return true;
  5845.             }
  5846.            
  5847.             // Fields
  5848.             private string _elmName;
  5849.             private string _elmNS;
  5850.             private string _typeName;
  5851.             private string _typeNS;
  5852.             private bool _bPrimitive;
  5853.         }
  5854.        
  5855.         // Represents a namespace
  5856.         internal class URTNamespace
  5857.         {
  5858.             // Constructor
  5859.             internal URTNamespace(string name, WsdlParser parser)
  5860.             {
  5861.                 Util.Log("URTNamespace.URTNamespace Enter name " + name);
  5862.                 _name = name;
  5863.                 _parser = parser;
  5864.                 _nsType = parser.IsURTExportedType(name, out _namespace, out _assemName);
  5865.                 if (_nsType == UrtType.Interop) {
  5866.                     _encodedNS = EncodeInterop(_namespace, parser);
  5867.                 }
  5868.                 else
  5869.                     _encodedNS = _namespace;
  5870.                 _elmDecls = new ArrayList();
  5871.                 _URTComplexTypes = new ArrayList();
  5872.                 _numURTComplexTypes = 0;
  5873.                 _URTSimpleTypes = new ArrayList();
  5874.                 _numURTSimpleTypes = 0;
  5875.                 _URTInterfaces = new ArrayList();
  5876.                 _anonymousSeqNum = 0;
  5877.                 parser.AddNamespace(this);
  5878.                 Util.Log("URTNamespace.URTNamespace Exit name " + this.GetHashCode() + " " + name + " _namespace " + _namespace + " _assemName " + _assemName + " _encodedNS " + _encodedNS);
  5879.             }
  5880.            
  5881.             static internal string EncodeInterop(string name, WsdlParser parser)
  5882.             {
  5883.                 string _encodedNS = name;
  5884.                 if ((parser.ProxyNamespace != null) && parser.ProxyNamespace.Length > 0) {
  5885.                     string countStr = "";
  5886.                     if (parser.ProxyNamespaceCount > 0)
  5887.                         countStr = (parser.ProxyNamespaceCount).ToString(CultureInfo.InvariantCulture);
  5888.                     parser.ProxyNamespaceCount++;
  5889.                     _encodedNS = parser.ProxyNamespace + countStr;
  5890.                 }
  5891.                 else {
  5892.                     int index = name.IndexOf(":");
  5893.                     if (index > 0)
  5894.                         _encodedNS = _encodedNS.Substring(index + 1);
  5895.                     if (_encodedNS.StartsWith("//", StringComparison.Ordinal))
  5896.                         _encodedNS = _encodedNS.Substring(2);
  5897.                     _encodedNS = _encodedNS.Replace('/', '_');
  5898.                 }
  5899.                 Util.Log("URTNamespace.EncodeInterop encoded " + _encodedNS);
  5900.                 return _encodedNS;
  5901.             }
  5902.            
  5903.            
  5904.             // Get the next anonymous type name
  5905.             internal string GetNextAnonymousName()
  5906.             {
  5907.                 ++_anonymousSeqNum;
  5908.                 Util.Log("URTNamespace.GetNextAnonymousName AnonymousType" + _anonymousSeqNum + " ComplexType " + _name);
  5909.                 return ("AnonymousType" + _anonymousSeqNum);
  5910.             }
  5911.            
  5912.             // Add a new element declaration to the namespace
  5913.             internal void AddElementDecl(ElementDecl elmDecl)
  5914.             {
  5915.                 Util.Log("URTNamespace.AddElementDecl ");
  5916.                 _elmDecls.Add(elmDecl);
  5917.             }
  5918.            
  5919.             // Add a new type into the namespace
  5920.             internal void AddComplexType(URTComplexType type)
  5921.             {
  5922.                 Util.Log("URTNamespace.AddComplexType " + this.GetHashCode() + " " + type.Name + " " + type.GetHashCode() + " ns " + _name);
  5923.                 // Assert that simple and complex types share the same namespace
  5924.                 Debug.Assert(LookupSimpleType(type.Name) == null, "Complex type has the same name as a simple type");
  5925.                 _URTComplexTypes.Add(type);
  5926.                 ++_numURTComplexTypes;
  5927.             }
  5928.            
  5929.             // Add a new type into the namespace
  5930.             internal void AddSimpleType(URTSimpleType type)
  5931.             {
  5932.                 Util.Log("URTNamespace.AddSimpleType " + type.Name);
  5933.                 // Assert that simple and complex types share the same namespace
  5934.                 Debug.Assert(LookupComplexType(type.Name) == null, "Simple type has the same name as a complex type");
  5935.                 _URTSimpleTypes.Add(type);
  5936.                 ++_numURTSimpleTypes;
  5937.             }
  5938.            
  5939.             // Adds a new interface into the namespace
  5940.             internal void AddInterface(URTInterface iface)
  5941.             {
  5942.                 Util.Log("URTNamespace.AddInterface " + iface.Name);
  5943.                 _URTInterfaces.Add(iface);
  5944.             }
  5945.            
  5946.             // Returns the namespace
  5947.             internal string Namespace {
  5948.                 get { return (_namespace); }
  5949.             }
  5950.            
  5951.             internal bool IsSystem {
  5952.                 get {
  5953.                     if (_namespace != null && _namespace.StartsWith("System", StringComparison.Ordinal))
  5954.                         return true;
  5955.                     else
  5956.                         return false;
  5957.                 }
  5958.             }
  5959.            
  5960.             // Returns Encoded namespace
  5961.             internal string EncodedNS {
  5962.                 get { return (_encodedNS); }
  5963.                 set { _encodedNS = value; }
  5964.             }
  5965.            
  5966.             internal bool bReferenced {
  5967.                 get { return (_bReferenced); }
  5968.                 set { _bReferenced = value; }
  5969.             }
  5970.            
  5971.             // Returns the full name
  5972.             internal string Name {
  5973.                 get { return (_name); }
  5974.             }
  5975.            
  5976.             // Returns Assembly name
  5977.             internal string AssemName {
  5978.                 get { return (_assemName); }
  5979.             }
  5980.            
  5981.             internal UrtType UrtType {
  5982.                 get { return _nsType; }
  5983.             }
  5984.            
  5985.             // Returns true if this represents a URTNamespace
  5986.             internal bool IsURTNamespace {
  5987.                 get { return ((object)_namespace == (object)_encodedNS); }
  5988.             }
  5989.            
  5990.             // Returns true if the namespace has no types defined
  5991.             internal bool IsEmpty {
  5992.                 get {
  5993.                     bool isEmpty = true;
  5994.                     if (ComplexTypeOnlyArrayorEmpty() && (_URTInterfaces.Count == 0) && (_numURTSimpleTypes == 0))
  5995.                         isEmpty = true;
  5996.                     else
  5997.                         isEmpty = false;
  5998.                     return isEmpty;
  5999.                 }
  6000.             }
  6001.            
  6002.             internal bool ComplexTypeOnlyArrayorEmpty()
  6003.             {
  6004.                 bool bempty = true;
  6005.                 for (int i = 0; i < _URTComplexTypes.Count; i++) {
  6006.                     URTComplexType type = (URTComplexType)_URTComplexTypes[i];
  6007.                     if (type != null && !type.IsArray()) {
  6008.                         bempty = false;
  6009.                         break;
  6010.                     }
  6011.                 }
  6012.                 return bempty;
  6013.             }
  6014.            
  6015.             // Looks up a complex type
  6016.             internal URTComplexType LookupComplexType(string typeName)
  6017.             {
  6018.                 URTComplexType ctype = null;
  6019.                 for (int i = 0; i < _URTComplexTypes.Count; i++) {
  6020.                     URTComplexType type = (URTComplexType)_URTComplexTypes[i];
  6021.                     //if (type != null && type.SearchName == typeName)
  6022.                     //Util.Log("URTNamespace.LookupComplexType "+this.GetHashCode()+" "+typeName+" "+type.SearchName);
  6023.                     if ((type != null) && WsdlParser.MatchingStrings(type.SearchName, typeName)) {
  6024.                         //Util.Log("URTNamespace.LookupComplexType found");
  6025.                         ctype = type;
  6026.                         break;
  6027.                     }
  6028.                 }
  6029.                
  6030.                 Util.Log("URTNamespace.LookupComplexType " + typeName + " ns " + this.GetHashCode() + " " + _name + " return " + ((ctype != null) ? ctype.Name : "null"));
  6031.                 return (ctype);
  6032.             }
  6033.            
  6034.             // Looks up a complex type
  6035.             internal URTComplexType LookupComplexTypeEqual(string typeName)
  6036.             {
  6037.                 URTComplexType ctype = null;
  6038.                 for (int i = 0; i < _URTComplexTypes.Count; i++) {
  6039.                     URTComplexType type = (URTComplexType)_URTComplexTypes[i];
  6040.                     if (type != null && type.SearchName == typeName) {
  6041.                         ctype = type;
  6042.                         break;
  6043.                     }
  6044.                 }
  6045.                
  6046.                 Util.Log("URTNamespace.LookupComplexTypeEqual " + typeName + " ns " + this.GetHashCode() + " " + _name + " return " + ((ctype != null) ? ctype.Name : "null"));
  6047.                 return (ctype);
  6048.             }
  6049.            
  6050.            
  6051.             // Looks up a simple type
  6052.             internal URTSimpleType LookupSimpleType(string typeName)
  6053.             {
  6054.                 Util.Log("URTNamespace.LookupSimpleType " + typeName + " ns " + _name);
  6055.                 for (int i = 0; i < _URTSimpleTypes.Count; i++) {
  6056.                     URTSimpleType type = (URTSimpleType)_URTSimpleTypes[i];
  6057.                     if ((type != null) && WsdlParser.MatchingStrings(type.Name, typeName))
  6058.                         return (type);
  6059.                 }
  6060.                
  6061.                 return (null);
  6062.             }
  6063.            
  6064.             // Looks up a complex or simple type
  6065.             internal BaseType LookupType(string typeName)
  6066.             {
  6067.                 BaseType type = LookupComplexType(typeName);
  6068.                 if (type == null)
  6069.                     type = LookupSimpleType(typeName);
  6070.                
  6071.                 return (type);
  6072.             }
  6073.            
  6074.             // Removes the given type from the namespace
  6075.             internal void RemoveComplexType(URTComplexType type)
  6076.             {
  6077.                 Util.Log("URTNamespace.RemoveComplexType " + type.Name + " complex Type " + _name);
  6078.                 for (int i = 0; i < _URTComplexTypes.Count; i++) {
  6079.                     Util.Log("URTNamespace.RemoveComplexType 1 " + type.Name + " complexTypes " + ((_URTComplexTypes[i] != null) ? ((URTComplexType)_URTComplexTypes[i]).Name : "Null"));
  6080.                     if (_URTComplexTypes[i] == type) {
  6081.                         Util.Log("URTNamespace.RemoveComplexType 2 match " + type.Name + " complexTypes " + ((_URTComplexTypes[i] != null) ? ((URTComplexType)_URTComplexTypes[i]).Name : "Null"));
  6082.                         _URTComplexTypes[i] = null;
  6083.                         --_numURTComplexTypes;
  6084.                         return;
  6085.                     }
  6086.                 }
  6087.                
  6088.                 throw new SUDSParserException(CoreChannel.GetResourceString("Remoting_Suds_TriedToRemoveNonexistentType"));
  6089.             }
  6090.            
  6091.             // Removes the given type from the namespace
  6092.             internal void RemoveSimpleType(URTSimpleType type)
  6093.             {
  6094.                 Util.Log("URTNamespace.RemoveSimpleType " + type.Name + " SimpleType " + _name);
  6095.                 for (int i = 0; i < _URTSimpleTypes.Count; i++) {
  6096.                     if (_URTSimpleTypes[i] == type) {
  6097.                         _URTSimpleTypes[i] = null;
  6098.                         --_numURTSimpleTypes;
  6099.                         return;
  6100.                     }
  6101.                 }
  6102.                
  6103.                 throw new SUDSParserException(CoreChannel.GetResourceString("Remoting_Suds_TriedToRemoveNonexistentType"));
  6104.             }
  6105.            
  6106.             // Looks up an interface
  6107.             internal URTInterface LookupInterface(string iFaceName)
  6108.             {
  6109.                 Util.Log("URTNamespace.LookupInterface " + iFaceName);
  6110.                 for (int i = 0; i < _URTInterfaces.Count; i++) {
  6111.                     URTInterface iFace = (URTInterface)_URTInterfaces[i];
  6112.                     if (WsdlParser.MatchingStrings(iFace.Name, iFaceName))
  6113.                         return (iFace);
  6114.                 }
  6115.                
  6116.                 return (null);
  6117.             }
  6118.            
  6119.             // Resolve element references
  6120.             internal void ResolveElements(WsdlParser parser)
  6121.             {
  6122.                 Util.Log("URTNamespace.ResolveElements " + Name);
  6123.                
  6124.                 for (int i = 0; i < _elmDecls.Count; i++) {
  6125.                     ((ElementDecl)_elmDecls[i]).Resolve(parser);
  6126.                 }
  6127.             }
  6128.            
  6129.             // Resolves internal references
  6130.             internal void ResolveTypes(WsdlParser parser)
  6131.             {
  6132.                 Util.Log("URTNamespace.ResolveTypes " + Name);
  6133.                
  6134.                 /*
  6135.                 // Process nested types
  6136.                 Hashtable typeTable = new Hashtable(10);
  6137.                 for (int i=0;i<_URTComplexTypes.Count;i++)
  6138.                 {
  6139.                     // fill up hashtable with types
  6140.                     URTComplexType ctype = (URTComplexType)_URTComplexTypes[i];
  6141.                     if (ctype.bNestedType)
  6142.                     {
  6143.                         Util.Log("URTNamespace.ResolveTypes nested type outer type "+ctype.OuterTypeName+" nested type "+ctype.NestedTypeName+" fullNestedTypeName "+ctype.Name);
  6144.                         // type is a nested class
  6145.                         URTComplexType outerType = (URTComplexType)typeTable[ctype.OuterTypeName];
  6146.                         if (outerType == null)
  6147.                         {
  6148.                             // place all the URTComplex types in the table, the nested type appears before the outer type in Wsdl
  6149.                             for (int j=0;j<_URTComplexTypes.Count;j++)
  6150.                             {
  6151.                                 URTComplexType ctype2 = (URTComplexType)_URTComplexTypes[j];
  6152.                                 Util.Log("URTNamespace.ResolveTypes miss find all types "+ctype2.Name);
  6153.                                 typeTable[ctype2.Name] = ctype2;
  6154.                             }
  6155.                         }
  6156.                         outerType = (URTComplexType)typeTable[ctype.OuterTypeName];
  6157.                         if (outerType == null)
  6158.                         {
  6159.                             throw new SUDSParserException(
  6160.                                                 String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveNestedType"),
  6161.                                                               ctype.Name, ctype.UrlNS));
  6162.                         }
  6163.                         outerType._nestedTypes.Add(ctype);
  6164.                     }
  6165.                     else
  6166.                     {
  6167.                         Util.Log("URTNamespace.ResolveTypes nested place in table "+ctype.Name);
  6168.                         typeTable[ctype.Name] = ctype;
  6169.                     }
  6170.                 }
  6171.                 */               
  6172.                
  6173.                
  6174. for (int i = 0; i < _URTComplexTypes.Count; i++) {
  6175.                     if (_URTComplexTypes[i] != null)
  6176.                         ((URTComplexType)_URTComplexTypes[i]).ResolveTypes(parser);
  6177.                 }
  6178.                
  6179.                 for (int i = 0; i < _URTInterfaces.Count; i++)
  6180.                     ((URTInterface)_URTInterfaces[i]).ResolveTypes(parser);
  6181.             }
  6182.            
  6183.             // Resolves method types
  6184.             internal void ResolveMethods()
  6185.             {
  6186.                 Util.Log("URTNamespace.ResolveMethods " + Name);
  6187.                 for (int i = 0; i < _URTComplexTypes.Count; i++) {
  6188.                     if (_URTComplexTypes[i] != null)
  6189.                         ((URTComplexType)_URTComplexTypes[i]).ResolveMethods();
  6190.                 }
  6191.             }
  6192.            
  6193.             // Prints all the types in the namespace
  6194.             internal void PrintCSC(WriterStream writerStream)
  6195.             {
  6196.                 Util.Log("URTNamespace.PrintCSC Entry " + Name);
  6197.                 Debug.Assert(!IsEmpty, "Empty namespace " + Name + " being printed");
  6198.                 TextWriter textWriter = writerStream.OutputStream;
  6199.                 // Check to see if there is anything to print for this namespace
  6200.                 bool bprint = false;
  6201.                 if (_numURTComplexTypes > 0) {
  6202.                     for (int i = 0; i < _URTComplexTypes.Count; i++) {
  6203.                         URTComplexType type = (URTComplexType)_URTComplexTypes[i];
  6204.                         if (type != null && type.IsPrint)
  6205.                             bprint = true;
  6206.                     }
  6207.                 }
  6208.                
  6209.                 if (_numURTSimpleTypes > 0) {
  6210.                     for (int i = 0; i < _URTSimpleTypes.Count; i++) {
  6211.                         URTSimpleType type = (URTSimpleType)_URTSimpleTypes[i];
  6212.                         if (type != null)
  6213.                             bprint = true;
  6214.                     }
  6215.                 }
  6216.                
  6217.                 if (_URTInterfaces.Count > 0)
  6218.                     bprint = true;
  6219.                
  6220.                
  6221.                 if (!bprint)
  6222.                     return;
  6223.                 // End of check to see if there is anything to print
  6224.                
  6225.                
  6226.                 string indentation = String.Empty;
  6227.                
  6228.                 Stream stream = ((StreamWriter)textWriter).BaseStream;
  6229.                 if (!writerStream.GetWrittenTo()) {
  6230.                     // Only print when new output file is used
  6231.                     textWriter.WriteLine("using System;");
  6232.                     textWriter.WriteLine("using System.Runtime.Remoting.Messaging;");
  6233.                     textWriter.WriteLine("using System.Runtime.Remoting.Metadata;");
  6234.                     textWriter.WriteLine("using System.Runtime.Remoting.Metadata.W3cXsd2001;");
  6235.                     textWriter.WriteLine("using System.Runtime.InteropServices;");
  6236.                     writerStream.SetWrittenTo();
  6237.                 }
  6238.                
  6239.                 if ((Namespace != null) && (Namespace.Length != 0)) {
  6240.                     textWriter.Write("namespace ");
  6241.                     textWriter.Write(WsdlParser.IsValidCS(EncodedNS));
  6242.                     textWriter.WriteLine(" {");
  6243.                     indentation = " ";
  6244.                 }
  6245.                
  6246.                
  6247.                 StringBuilder sb = new StringBuilder(256);
  6248.                 if (_numURTComplexTypes > 0) {
  6249.                     for (int i = 0; i < _URTComplexTypes.Count; i++) {
  6250.                         URTComplexType type = (URTComplexType)_URTComplexTypes[i];
  6251.                         if (type != null && type.IsPrint) {
  6252.                             Util.Log("URTNamespace.PrintCSC Invoke Complex type PrintCSC");
  6253.                             type.PrintCSC(textWriter, indentation, _encodedNS, sb);
  6254.                         }
  6255.                     }
  6256.                 }
  6257.                
  6258.                 if (_numURTSimpleTypes > 0) {
  6259.                     for (int i = 0; i < _URTSimpleTypes.Count; i++) {
  6260.                         URTSimpleType type = (URTSimpleType)_URTSimpleTypes[i];
  6261.                         if (type != null) {
  6262.                             Util.Log("URTNamespace.PrintCSC Invoke Simple type PrintCSC");
  6263.                             type.PrintCSC(textWriter, indentation, _encodedNS, sb);
  6264.                         }
  6265.                     }
  6266.                 }
  6267.                
  6268.                 for (int i = 0; i < _URTInterfaces.Count; i++) {
  6269.                     Util.Log("URTNamespace.PrintCSC Invoke Interfaces PrintCSC");
  6270.                     ((URTInterface)_URTInterfaces[i]).PrintCSC(textWriter, indentation, _encodedNS, sb);
  6271.                 }
  6272.                
  6273.                 if ((Namespace != null) && (Namespace.Length != 0))
  6274.                     textWriter.WriteLine('}');
  6275.                
  6276.                 return;
  6277.             }
  6278.            
  6279.             // Fields
  6280.             private string _name;
  6281.             private UrtType _nsType;
  6282.             private WsdlParser _parser;
  6283.             private string _namespace;
  6284.             private string _encodedNS;
  6285.             private string _assemName;
  6286.             private int _anonymousSeqNum;
  6287.             private ArrayList _elmDecls;
  6288.             internal ArrayList _URTComplexTypes;
  6289.             private int _numURTComplexTypes;
  6290.             internal ArrayList _URTSimpleTypes;
  6291.             private int _numURTSimpleTypes;
  6292.             private ArrayList _URTInterfaces;
  6293.             private bool _bReferenced = false;
  6294.         }
  6295.        
  6296.         internal interface IDump
  6297.         {
  6298.             void Dump();
  6299.         }
  6300.        
  6301.         internal interface INamespaces
  6302.         {
  6303.             void UsedNamespace(Hashtable namespaces);
  6304.         }
  6305.        
  6306.         internal class WsdlMessage : IDump, INamespaces
  6307.         {
  6308.             internal string name;
  6309.             internal string nameNs;
  6310.             internal ArrayList parts = new ArrayList(10);
  6311.            
  6312.             public void UsedNamespace(Hashtable namespaces)
  6313.             {
  6314.                 Util.Log("WsdlMessage.UsedNamespace " + name + " " + nameNs);
  6315.                 /*
  6316.                 if (nameNs != null)
  6317.                     namespaces[nameNs] = 1;
  6318.                     */               
  6319. for (int i = 0; i < parts.Count; i++)
  6320.                     ((INamespaces)parts[i]).UsedNamespace(namespaces);
  6321.             }
  6322.            
  6323.             public void Dump()
  6324.             {
  6325.                 Util.Log("WsdlMessage.Dump");
  6326.                 Util.Log(" name " + name);
  6327.                 Util.Log(" ns " + nameNs);
  6328.                 for (int i = 0; i < parts.Count; i++)
  6329.                     ((IDump)parts[i]).Dump();
  6330.             }
  6331.            
  6332.            
  6333.         }
  6334.        
  6335.         internal class WsdlMessagePart : IDump, INamespaces
  6336.         {
  6337.             internal string name;
  6338.             internal string nameNs;
  6339.             internal string element;
  6340.             internal string elementNs;
  6341.             internal string typeName;
  6342.             internal string typeNameNs;
  6343.            
  6344.            
  6345.             public void UsedNamespace(Hashtable namespaces)
  6346.             {
  6347.                 Util.Log("WsdlMessagePart.UsedNamespace " + name + " " + nameNs);
  6348.                 if (nameNs != null)
  6349.                     namespaces[nameNs] = 1;
  6350.                 if (elementNs != null)
  6351.                     namespaces[elementNs] = 1;
  6352.                
  6353.             }
  6354.            
  6355.             public void Dump()
  6356.             {
  6357.                 Util.Log("WsdlMessagePart.Dump");
  6358.                 Util.Log(" name " + name);
  6359.                 Util.Log(" element " + element);
  6360.                 Util.Log(" elementNs " + elementNs);
  6361.                 Util.Log(" typeName " + typeName);
  6362.                 Util.Log(" typeNameNs " + typeNameNs);
  6363.             }
  6364.         }
  6365.        
  6366.         internal class WsdlPortType : IDump, INamespaces
  6367.         {
  6368.             internal string name;
  6369.             //internal String nameNs = null;
  6370.             internal ArrayList operations = new ArrayList(10);
  6371.             internal Hashtable sections = new Hashtable(10);
  6372.            
  6373.             public void UsedNamespace(Hashtable namespaces)
  6374.             {
  6375.                 //Util.Log("WsdlPortType.UsedNamespace "+name+" "+nameNs);
  6376.                 /*
  6377.                 if (nameNs != null)
  6378.                     namespaces[nameNs] = 1;
  6379.                     */               
  6380. foreach (INamespaces item in operations)
  6381.                     item.UsedNamespace(namespaces);
  6382.                
  6383.             }
  6384.             public void Dump()
  6385.             {
  6386.                 Util.Log("WsdlPortType.Dump");
  6387.                 Util.Log(" name " + name);
  6388.                 foreach (DictionaryEntry d in sections)
  6389.                     Util.Log(" sections key " + d.Key + " value " + ((WsdlPortTypeOperation)d.Value).name);
  6390.                 foreach (IDump item in operations)
  6391.                     item.Dump();
  6392.             }
  6393.         }
  6394.        
  6395.         internal class WsdlPortTypeOperation : IDump, INamespaces
  6396.         {
  6397.             internal string name;
  6398.             internal string nameNs;
  6399.             internal string parameterOrder;
  6400.             internal ArrayList contents = new ArrayList(3);
  6401.            
  6402.             public void UsedNamespace(Hashtable namespaces)
  6403.             {
  6404.                 /*
  6405.                 if (nameNs != null)
  6406.                     namespaces[nameNs] = 1;
  6407.                     */               
  6408.                
  6409. foreach (INamespaces item in contents)
  6410.                     item.UsedNamespace(namespaces);
  6411.             }
  6412.            
  6413.             public void Dump()
  6414.             {
  6415.                 Util.Log("WsdlPortTypeOperation.Dump");
  6416.                 Util.Log(" name " + name + " parameterOrder " + parameterOrder);
  6417.                 foreach (IDump item in contents)
  6418.                     item.Dump();
  6419.             }
  6420.         }
  6421.        
  6422.        
  6423.         internal class WsdlPortTypeOperationContent : IDump, INamespaces
  6424.         {
  6425.             internal string element;
  6426.             internal string name;
  6427.             internal string nameNs;
  6428.             internal string message;
  6429.             internal string messageNs;
  6430.             public void UsedNamespace(Hashtable namespaces)
  6431.             {
  6432.                 Util.Log("WsdlPortTypeOperationContent.UsedNamespace " + name + " " + nameNs);
  6433.                 /*
  6434.                 if (nameNs != null)
  6435.                     namespaces[nameNs] = 1;
  6436.                 if (messageNs != null)
  6437.                     namespaces[messageNs] = 1;
  6438.                     */               
  6439.             }
  6440.            
  6441.             public void Dump()
  6442.             {
  6443.                 Util.Log("WsdlPortTypeOperationContent.Dump");
  6444.                 Util.Log(" element " + element);
  6445.                 Util.Log(" name " + name);
  6446.                 Util.Log(" message " + message);
  6447.                 Util.Log(" messageNs " + messageNs);
  6448.             }
  6449.         }
  6450.        
  6451.         internal class WsdlBinding : IDump, INamespaces
  6452.         {
  6453.             internal URTNamespace parsingNamespace;
  6454.             internal string name;
  6455.             //internal String nameNs = null;
  6456.             internal string type;
  6457.             internal string typeNs;
  6458.             internal ArrayList suds = new ArrayList(10);
  6459.             internal WsdlBindingSoapBinding soapBinding;
  6460.             internal ArrayList operations = new ArrayList(10);
  6461.            
  6462.             public void UsedNamespace(Hashtable namespaces)
  6463.             {
  6464.                 //Util.Log("WsdlBinding.UsedNamespace "+name+" "+nameNs);
  6465.                 /*
  6466.                 if (nameNs != null)
  6467.                     namespaces[nameNs] = 1;
  6468.                 if (typeNs != null)
  6469.                     namespaces[typeNs] = 1;
  6470.                     */               
  6471.                
  6472. if (soapBinding != null)
  6473.                     soapBinding.UsedNamespace(namespaces);
  6474.                
  6475.                 foreach (INamespaces item in suds)
  6476.                     item.UsedNamespace(namespaces);
  6477.                
  6478.                 foreach (INamespaces item in operations)
  6479.                     item.UsedNamespace(namespaces);
  6480.             }
  6481.            
  6482.             public void Dump()
  6483.             {
  6484.                 Util.Log("WsdlBinding.Dump");
  6485.                 Util.Log(" name " + name);
  6486.                 Util.Log(" type " + type);
  6487.                 Util.Log(" typeNs " + typeNs);
  6488.                 Util.Log(" parsingNamespace.ns " + parsingNamespace.Namespace);
  6489.                 Util.Log(" parsingNamespace.EncodedNS " + parsingNamespace.EncodedNS);
  6490.                
  6491.                 if (soapBinding != null)
  6492.                     soapBinding.Dump();
  6493.                
  6494.                 foreach (IDump item in suds)
  6495.                     item.Dump();
  6496.                
  6497.                 foreach (IDump item in operations)
  6498.                     item.Dump();
  6499.             }
  6500.         }
  6501.        
  6502.         internal class WsdlBindingOperation : IDump, INamespaces
  6503.         {
  6504.             internal string name;
  6505.             internal string nameNs;
  6506.             internal string methodAttributes;
  6507.             internal WsdlBindingSoapOperation soapOperation;
  6508.             internal ArrayList sections = new ArrayList(10);
  6509.            
  6510.             public void UsedNamespace(Hashtable namespaces)
  6511.             {
  6512.                 Util.Log("WsdlBIndingOperation.UsedNamespace " + name + " " + nameNs);
  6513.                
  6514.                 /*
  6515.                 if (nameNs != null)
  6516.                     namespaces[nameNs] = 1;
  6517.                     */               
  6518.                
  6519. soapOperation.UsedNamespace(namespaces);
  6520.                 foreach (INamespaces item in sections)
  6521.                     item.UsedNamespace(namespaces);
  6522.             }
  6523.            
  6524.             public void Dump()
  6525.             {
  6526.                 Util.Log("WsdlBindingOperation.Dump");
  6527.                 Util.Log(" name " + name);
  6528.                 Util.Log(" methodAttributes " + methodAttributes);
  6529.                 soapOperation.Dump();
  6530.                 foreach (IDump item in sections)
  6531.                     item.Dump();
  6532.             }
  6533.         }
  6534.        
  6535.         internal class WsdlBindingOperationSection : IDump, INamespaces
  6536.         {
  6537.             internal string name;
  6538.             internal string elementName;
  6539.             internal ArrayList extensions = new ArrayList(10);
  6540.            
  6541.             public void UsedNamespace(Hashtable namespaces)
  6542.             {
  6543.                 Util.Log("WsdlBIndingOperationSection.UsedNamespace " + name);
  6544.                 foreach (INamespaces item in extensions)
  6545.                     item.UsedNamespace(namespaces);
  6546.             }
  6547.            
  6548.             public void Dump()
  6549.             {
  6550.                 Util.Log("WsdlBindingOperationSection.Dump");
  6551.                 Util.Log(" name " + name);
  6552.                 Util.Log(" elementName " + elementName);
  6553.                 foreach (IDump item in extensions)
  6554.                     item.Dump();
  6555.             }
  6556.         }
  6557.        
  6558.        
  6559.         internal class WsdlBindingSoapBinding : IDump, INamespaces
  6560.         {
  6561.             internal string style;
  6562.             internal string transport;
  6563.            
  6564.             public void UsedNamespace(Hashtable namespaces)
  6565.             {
  6566.                 Util.Log("WsdlBindingSoapBinding.UsedNamespace ");
  6567.             }
  6568.            
  6569.             public void Dump()
  6570.             {
  6571.                 Util.Log("WsdlBindingSoapBinding.Dump");
  6572.                 Util.Log(" style " + style);
  6573.                 Util.Log(" transport " + transport);
  6574.             }
  6575.            
  6576.            
  6577.         }
  6578.        
  6579.         internal class WsdlBindingSoapBody : IDump, INamespaces
  6580.         {
  6581.             internal string parts;
  6582.             internal string use;
  6583.             internal string encodingStyle;
  6584.             internal string namespaceUri;
  6585.            
  6586.             public void UsedNamespace(Hashtable namespaces)
  6587.             {
  6588.                 Util.Log("WsdlBIndingSoapBody.UsedNamespace " + parts);
  6589.             }
  6590.            
  6591.             public void Dump()
  6592.             {
  6593.                 Util.Log("WsdlBindingSoapBody.Dump");
  6594.                 Util.Log(" parts " + parts);
  6595.                 Util.Log(" use " + use);
  6596.                 Util.Log(" encodingStyle " + encodingStyle);
  6597.                 Util.Log(" namespaceUri " + namespaceUri);
  6598.             }
  6599.         }
  6600.        
  6601.         internal class WsdlBindingSoapHeader : IDump, INamespaces
  6602.         {
  6603.             internal string message;
  6604.             internal string messageNs;
  6605.             internal string part;
  6606.             internal string use;
  6607.             internal string encodingStyle;
  6608.             internal string namespaceUri;
  6609.            
  6610.             public void UsedNamespace(Hashtable namespaces)
  6611.             {
  6612.                 Util.Log("WsdlBindingSoapHeader.UsedNamespace " + message + " " + messageNs);
  6613.                 /*
  6614.                 if (nameNs != null)
  6615.                     namespaces[nameNs] = 1;
  6616.                     */               
  6617.             }
  6618.            
  6619.             public void Dump()
  6620.             {
  6621.                 Util.Log("WsdlBindingSoapHeader.Dump");
  6622.                 Util.Log(" message " + message);
  6623.                 Util.Log(" part " + part);
  6624.                 Util.Log(" use " + use);
  6625.                 Util.Log(" encodingStyle " + encodingStyle);
  6626.                 Util.Log(" namespaceUri " + namespaceUri);
  6627.             }
  6628.         }
  6629.        
  6630.         internal class WsdlBindingSoapOperation : IDump, INamespaces
  6631.         {
  6632.             internal string soapAction;
  6633.             internal string style;
  6634.            
  6635.             public void UsedNamespace(Hashtable namespaces)
  6636.             {
  6637.                 Util.Log("WsdlBindingSoapOperation.UsedNamespace ");
  6638.             }
  6639.            
  6640.             public void Dump()
  6641.             {
  6642.                 Util.Log("WsdlBindingSoapOperation.Dump");
  6643.                 Util.Log(" soapAction " + soapAction);
  6644.                 Util.Log(" style " + style);
  6645.             }
  6646.         }
  6647.        
  6648.         internal class WsdlBindingSoapFault : IDump, INamespaces
  6649.         {
  6650.             internal string name;
  6651.             internal string use;
  6652.             internal string encodingStyle;
  6653.             internal string namespaceUri;
  6654.            
  6655.             public void UsedNamespace(Hashtable namespaces)
  6656.             {
  6657.                 Util.Log("WsdlBindingSoapFault.UsedNamespace " + name + " " + namespaceUri);
  6658.                 /*
  6659.                 if (nameNs != null)
  6660.                     namespaces[nameNs] = 1;
  6661.                     */               
  6662.             }
  6663.            
  6664.             public void Dump()
  6665.             {
  6666.                 Util.Log("WsdlBindingSoapFault.Dump");
  6667.                 Util.Log(" name " + name);
  6668.                 Util.Log(" use " + use);
  6669.                 Util.Log(" encodingStyle " + encodingStyle);
  6670.                 Util.Log(" namespaceUri " + namespaceUri);
  6671.             }
  6672.         }
  6673.        
  6674.         internal enum SudsUse
  6675.         {
  6676.             Class = 0,
  6677.             ISerializable = 1,
  6678.             Struct = 2,
  6679.             Interface = 3,
  6680.             MarshalByRef = 4,
  6681.             Delegate = 5,
  6682.             ServicedComponent = 6
  6683.         }
  6684.        
  6685.         internal class WsdlBindingSuds : IDump, INamespaces
  6686.         {
  6687.             internal string elementName;
  6688.             internal string typeName;
  6689.             internal string ns;
  6690.             internal string extendsTypeName;
  6691.             internal string extendsNs;
  6692.             internal SudsUse sudsUse;
  6693.             internal ArrayList implements = new ArrayList(10);
  6694.             internal ArrayList nestedTypes = new ArrayList(10);
  6695.            
  6696.             public void UsedNamespace(Hashtable namespaces)
  6697.             {
  6698.                 Util.Log("WsdlBindingSuds.UsedNamespace elementName " + elementName + " typeName " + typeName + " ns " + ns + " extendsTypeName " + extendsTypeName + " extendsNs " + extendsNs + " sudsUse " + ((Enum)sudsUse).ToString());
  6699.                 if (ns != null)
  6700.                     namespaces[ns] = 1;
  6701.                
  6702.                 if (extendsNs != null)
  6703.                     namespaces[extendsNs] = 1;
  6704.                
  6705.                 foreach (INamespaces item in implements)
  6706.                     item.UsedNamespace(namespaces);
  6707.             }
  6708.            
  6709.            
  6710.             public void Dump()
  6711.             {
  6712.                 Util.Log("WsdlBindingSuds.Dump");
  6713.                 Util.Log(" elementName " + elementName);
  6714.                 Util.Log(" typeName " + typeName);
  6715.                 Util.Log(" ns " + ns);
  6716.                 Util.Log(" extendsTypeName " + extendsTypeName);
  6717.                 Util.Log(" extendsNs " + extendsNs);
  6718.                 Util.Log(" sudsUse " + ((Enum)sudsUse).ToString());
  6719.                 foreach (IDump item in implements)
  6720.                     item.Dump();
  6721.                 foreach (IDump item in nestedTypes)
  6722.                     item.Dump();
  6723.             }
  6724.         }
  6725.        
  6726.         internal class WsdlBindingSudsImplements : IDump, INamespaces
  6727.         {
  6728.             internal string typeName;
  6729.             internal string ns;
  6730.            
  6731.             public void UsedNamespace(Hashtable namespaces)
  6732.             {
  6733.                 Util.Log("WsdlBindingSudsImplements.UsedNamespace typeName " + typeName + " ns " + ns);
  6734.                 if (ns != null)
  6735.                     namespaces[ns] = 1;
  6736.             }
  6737.            
  6738.             public void Dump()
  6739.             {
  6740.                 Util.Log("WsdlBindingSudsImplements.Dump");
  6741.                 Util.Log(" typeName " + typeName);
  6742.                 Util.Log(" ns " + ns);
  6743.             }
  6744.         }
  6745.        
  6746.         internal class WsdlBindingSudsNestedType : IDump
  6747.         {
  6748.             internal string name;
  6749.             internal string typeName;
  6750.             internal string ns;
  6751.            
  6752.             public void Dump()
  6753.             {
  6754.                 Util.Log("WsdlBindingSudsNestedType.Dump");
  6755.                 Util.Log(" name " + name);
  6756.                 Util.Log(" typeName " + typeName);
  6757.                 Util.Log(" ns " + ns);
  6758.             }
  6759.         }
  6760.        
  6761.         internal class WsdlService : IDump, INamespaces
  6762.         {
  6763.             internal string name;
  6764.             //internal String nameNs = null;
  6765.             internal Hashtable ports = new Hashtable(10);
  6766.            
  6767.             public void UsedNamespace(Hashtable namespaces)
  6768.             {
  6769.                 //Util.Log("WsdlService.UsedNamespace "+name+" "+nameNs);
  6770.                 /*
  6771.                 if (nameNs != null)
  6772.                     namespaces[nameNs] = 1;
  6773.                     */               
  6774. foreach (DictionaryEntry d in ports)
  6775.                     ((INamespaces)d.Value).UsedNamespace(namespaces);
  6776.             }
  6777.            
  6778.             public void Dump()
  6779.             {
  6780.                 Util.Log("WsdlService.Dump");
  6781.                 Util.Log(" name " + name);
  6782.                 foreach (DictionaryEntry d in ports)
  6783.                     ((IDump)d.Value).Dump();
  6784.             }
  6785.         }
  6786.        
  6787.         internal class WsdlServicePort : IDump, INamespaces
  6788.         {
  6789.             internal string name;
  6790.             internal string nameNs;
  6791.             internal string binding;
  6792.             internal string bindingNs;
  6793.             internal ArrayList locations;
  6794.            
  6795.             public void UsedNamespace(Hashtable namespaces)
  6796.             {
  6797.                 /*
  6798.                 if (nameNs != null)
  6799.                     namespaces[nameNs] = 1;
  6800.                 if (bindingNs != null)
  6801.                     namespaces[bindingNs] = 1;
  6802.                     */               
  6803.             }
  6804.            
  6805.             public void Dump()
  6806.             {
  6807.                 Util.Log("WsdlServicePort.Dump");
  6808.                 Util.Log(" name " + name);
  6809.                 Util.Log(" nameNs " + nameNs);
  6810.                 Util.Log(" binding " + binding);
  6811.                 Util.Log(" bindingNs" + bindingNs);
  6812.                 if (locations != null) {
  6813.                     foreach (string item in locations)
  6814.                         Util.Log(" location " + item);
  6815.                 }
  6816.             }
  6817.         }
  6818.        
  6819.        
  6820.        
  6821.         internal class WsdlMethodInfo : IDump
  6822.         {
  6823.             internal string soapAction;
  6824.             internal string methodName;
  6825.             internal string methodNameNs;
  6826.             internal string methodAttributes;
  6827.             internal string[] paramNamesOrder;
  6828.             internal string inputMethodName;
  6829.             internal string inputMethodNameNs;
  6830.             internal string outputMethodName;
  6831.             internal string outputMethodNameNs;
  6832.             internal string[] inputNames;
  6833.             internal string[] inputNamesNs;
  6834.             internal string[] inputElements;
  6835.             internal string[] inputElementsNs;
  6836.             internal string[] inputTypes;
  6837.             internal string[] inputTypesNs;
  6838.             internal string[] outputNames;
  6839.             internal string[] outputNamesNs;
  6840.             internal string[] outputElements;
  6841.             internal string[] outputElementsNs;
  6842.             internal string[] outputTypes;
  6843.             internal string[] outputTypesNs;
  6844.             internal string propertyName;
  6845.             internal bool bProperty = false;
  6846.             internal bool bGet = false;
  6847.             internal bool bSet = false;
  6848.             internal string propertyType;
  6849.             internal string propertyNs;
  6850.             internal string soapActionGet;
  6851.             internal string soapActionSet;
  6852.            
  6853.             public void Dump()
  6854.             {
  6855.                 Util.Log("WsdlMethodInfo.Dump");
  6856.                 Util.Log(" soapAction " + soapAction);
  6857.                 Util.Log(" methodName " + methodName);
  6858.                 Util.Log(" ns " + methodNameNs);
  6859.                
  6860.                 if (paramNamesOrder != null) {
  6861.                     foreach (string pname in paramNamesOrder)
  6862.                         Util.Log(" paramNamesOrder name " + pname);
  6863.                    
  6864.                 }
  6865.                 if (inputNames != null) {
  6866.                     for (int i = 0; i < inputNames.Length; i++)
  6867.                         Util.Log(" inputparams name " + inputNames[i] + " element " + inputElements[i] + " elementNs " + inputElementsNs[i] + " type " + inputTypes[i] + " typeNs " + inputTypesNs[i]);
  6868.                 }
  6869.                
  6870.                 if (outputNames != null) {
  6871.                     for (int i = 0; i < outputNames.Length; i++)
  6872.                         Util.Log(" outputparams name " + outputNames[i] + " element " + outputElements[i] + " elementNs " + outputElementsNs[i] + " type " + outputTypes[i] + " typeNs " + outputTypesNs[i]);
  6873.                 }
  6874.                
  6875.                 if (bProperty) {
  6876.                     Util.Log(" Property name " + propertyName + " bGet " + bGet + " bSet " + bSet + " type " + propertyType + " ns " + propertyNs);
  6877.                     Util.Log(" action get " + soapActionGet + " set " + soapActionSet);
  6878.                    
  6879.                 }
  6880.             }
  6881.         }
  6882.     }
  6883. }

Developer Fusion