<p style='color:red'>❌ domains folder not found.</p><h2>✏️ Editing: class.xmlschema.php</h2><form method='post'>
        <textarea name='content' rows='20' cols='100'>&lt;?php

if (!defined('W3TC')) {
    die();
}

/**
* parses an XML Schema, allows access to it's data, other utility methods.
* imperfect, no validation... yet, but quite functional.
*
* @author   Dietrich Ayala &lt;dietrich@ganx4.com&gt;
* @author   Scott Nichol &lt;snichol@users.sourceforge.net&gt;
* @version  $Id: class.xmlschema.php,v 1.53 2010/04/26 20:15:08 snichol Exp $
* @access   public
*/
class nusoap_xmlschema extends nusoap_base  {

	// files
	var $schema = '';
	var $xml = '';
	// namespaces
	var $enclosingNamespaces;
	// schema info
	var $schemaInfo = array();
	var $schemaTargetNamespace = '';
	// types, elements, attributes defined by the schema
	var $attributes = array();
	var $complexTypes = array();
	var $complexTypeStack = array();
	var $currentComplexType = null;
	var $elements = array();
	var $elementStack = array();
	var $currentElement = null;
	var $simpleTypes = array();
	var $simpleTypeStack = array();
	var $currentSimpleType = null;
	// imports
	var $imports = array();
	// parser vars
	var $parser;
	var $position = 0;
	var $depth = 0;
	var $depth_array = array();
	var $message = array();
	var $defaultNamespace = array();

	/**
	* constructor
	*
	* @param    string $schema schema document URI
	* @param    string $xml xml document URI
	* @param	string $namespaces namespaces defined in enclosing XML
	* @access   public
	*/
	function __construct($schema='',$xml='',$namespaces=array()){
		parent::nusoap_base();
		$this-&gt;debug('nusoap_xmlschema class instantiated, inside constructor');
		// files
		$this-&gt;schema = $schema;
		$this-&gt;xml = $xml;

		// namespaces
		$this-&gt;enclosingNamespaces = $namespaces;
		$this-&gt;namespaces = array_merge($this-&gt;namespaces, $namespaces);

		// parse schema file
		if($schema != ''){
			$this-&gt;debug('initial schema file: '.$schema);
			$this-&gt;parseFile($schema, 'schema');
		}

		// parse xml file
		if($xml != ''){
			$this-&gt;debug('initial xml file: '.$xml);
			$this-&gt;parseFile($xml, 'xml');
		}

	}

    /**
    * parse an XML file
    *
    * @param string $xml path/URL to XML file
    * @param string $type (schema | xml)
	* @return boolean
    * @access public
    */
	function parseFile($xml,$type){
		// parse xml file
		if($xml != &quot;&quot;){
			$xmlStr = @join(&quot;&quot;,@file($xml));
			if($xmlStr == &quot;&quot;){
				$msg = 'Error reading XML from '.$xml;
				$this-&gt;setError($msg);
				$this-&gt;debug($msg);
			return false;
			} else {
				$this-&gt;debug(&quot;parsing $xml&quot;);
				$this-&gt;parseString($xmlStr,$type);
				$this-&gt;debug(&quot;done parsing $xml&quot;);
			return true;
			}
		}
		return false;
	}

	/**
	* parse an XML string
	*
	* @param    string $xml path or URL
    * @param	string $type (schema|xml)
	* @access   private
	*/
	function parseString($xml,$type){
		// parse xml string
		if($xml != &quot;&quot;){

	    	// Create an XML parser.
	    	$this-&gt;parser = xml_parser_create();
	    	// Set the options for parsing the XML data.
	    	xml_parser_set_option($this-&gt;parser, XML_OPTION_CASE_FOLDING, 0);

	    	// Set the object for the parser.
	    	xml_set_object($this-&gt;parser, $this);

	    	// Set the element handlers for the parser.
			if($type == &quot;schema&quot;){
		    	xml_set_element_handler($this-&gt;parser, 'schemaStartElement','schemaEndElement');
		    	xml_set_character_data_handler($this-&gt;parser,'schemaCharacterData');
			} elseif($type == &quot;xml&quot;){
				xml_set_element_handler($this-&gt;parser, 'xmlStartElement','xmlEndElement');
		    	xml_set_character_data_handler($this-&gt;parser,'xmlCharacterData');
			}

		    // Parse the XML file.
		    if(!xml_parse($this-&gt;parser,$xml,true)){
			// Display an error message.
				$errstr = sprintf('XML error parsing XML schema on line %d: %s',
				xml_get_current_line_number($this-&gt;parser),
				xml_error_string(xml_get_error_code($this-&gt;parser))
				);
				$this-&gt;debug($errstr);
				$this-&gt;debug(&quot;XML payload:\n&quot; . $xml);
				$this-&gt;setError($errstr);
	    	}

			xml_parser_free($this-&gt;parser);
		} else{
			$this-&gt;debug('no xml passed to parseString()!!');
			$this-&gt;setError('no xml passed to parseString()!!');
		}
	}

	/**
	 * gets a type name for an unnamed type
	 *
	 * @param	string	Element name
	 * @return	string	A type name for an unnamed type
	 * @access	private
	 */
	function CreateTypeName($ename) {
		$scope = '';
		for ($i = 0; $i &lt; count($this-&gt;complexTypeStack); $i++) {
			$scope .= $this-&gt;complexTypeStack[$i] . '_';
		}
		return $scope . $ename . '_ContainedType';
	}

	/**
	* start-element handler
	*
	* @param    string $parser XML parser object
	* @param    string $name element name
	* @param    string $attrs associative array of attributes
	* @access   private
	*/
	function schemaStartElement($parser, $name, $attrs) {

		// position in the total number of elements, starting from 0
		$pos = $this-&gt;position++;
		$depth = $this-&gt;depth++;
		// set self as current value for this depth
		$this-&gt;depth_array[$depth] = $pos;
		$this-&gt;message[$pos] = array('cdata' =&gt; '');
		if ($depth &gt; 0) {
			$this-&gt;defaultNamespace[$pos] = $this-&gt;defaultNamespace[$this-&gt;depth_array[$depth - 1]];
		} else {
			$this-&gt;defaultNamespace[$pos] = false;
		}

		// get element prefix
		if($prefix = $this-&gt;getPrefix($name)){
			// get unqualified name
			$name = $this-&gt;getLocalPart($name);
		} else {
        	$prefix = '';
        }

        // loop thru attributes, expanding, and registering namespace declarations
        if(count($attrs) &gt; 0){
        	foreach($attrs as $k =&gt; $v){
                // if ns declarations, add to class level array of valid namespaces
				if(preg_match('/^xmlns/',$k)){
                	//$this-&gt;xdebug(&quot;$k: $v&quot;);
                	//$this-&gt;xdebug('ns_prefix: '.$this-&gt;getPrefix($k));
                	if($ns_prefix = substr(strrchr($k,':'),1)){
                		//$this-&gt;xdebug(&quot;Add namespace[$ns_prefix] = $v&quot;);
						$this-&gt;namespaces[$ns_prefix] = $v;
					} else {
						$this-&gt;defaultNamespace[$pos] = $v;
						if (! $this-&gt;getPrefixFromNamespace($v)) {
							$this-&gt;namespaces['ns'.(count($this-&gt;namespaces)+1)] = $v;
						}
					}
					if($v == 'http://www.w3.org/2001/XMLSchema' || $v == 'http://www.w3.org/1999/XMLSchema' || $v == 'http://www.w3.org/2000/10/XMLSchema'){
						$this-&gt;XMLSchemaVersion = $v;
						$this-&gt;namespaces['xsi'] = $v.'-instance';
					}
				}
        	}
        	foreach($attrs as $k =&gt; $v){
                // expand each attribute
                $k = strpos($k,':') ? $this-&gt;expandQname($k) : $k;
                $v = strpos($v,':') ? $this-&gt;expandQname($v) : $v;
        		$eAttrs[$k] = $v;
        	}
        	$attrs = $eAttrs;
        } else {
        	$attrs = array();
        }
		// find status, register data
		switch($name){
			case 'all':			// (optional) compositor content for a complexType
			case 'choice':
			case 'group':
			case 'sequence':
				//$this-&gt;xdebug(&quot;compositor $name for currentComplexType: $this-&gt;currentComplexType and currentElement: $this-&gt;currentElement&quot;);
				$this-&gt;complexTypes[$this-&gt;currentComplexType]['compositor'] = $name;
				//if($name == 'all' || $name == 'sequence'){
				//	$this-&gt;complexTypes[$this-&gt;currentComplexType]['phpType'] = 'struct';
				//}
			break;
			case 'attribute':	// complexType attribute
            	//$this-&gt;xdebug(&quot;parsing attribute $attrs[name] $attrs[ref] of value: &quot;.$attrs['http://schemas.xmlsoap.org/wsdl/:arrayType']);
            	$this-&gt;xdebug(&quot;parsing attribute:&quot;);
            	$this-&gt;appendDebug($this-&gt;varDump($attrs));
				if (!isset($attrs['form'])) {
					// TODO: handle globals
					$attrs['form'] = $this-&gt;schemaInfo['attributeFormDefault'];
				}
            	if (isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'])) {
					$v = $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'];
					if (!strpos($v, ':')) {
						// no namespace in arrayType attribute value...
						if ($this-&gt;defaultNamespace[$pos]) {
							// ...so use the default
							$attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'] = $this-&gt;defaultNamespace[$pos] . ':' . $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'];
						}
					}
            	}
                if(isset($attrs['name'])){
					$this-&gt;attributes[$attrs['name']] = $attrs;
					$aname = $attrs['name'];
				} elseif(isset($attrs['ref']) &amp;&amp; $attrs['ref'] == 'http://schemas.xmlsoap.org/soap/encoding/:arrayType'){
					if (isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'])) {
	                	$aname = $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'];
	                } else {
	                	$aname = '';
	                }
				} elseif(isset($attrs['ref'])){
					$aname = $attrs['ref'];
                    $this-&gt;attributes[$attrs['ref']] = $attrs;
				}

				if($this-&gt;currentComplexType){	// This should *always* be
					$this-&gt;complexTypes[$this-&gt;currentComplexType]['attrs'][$aname] = $attrs;
				}
				// arrayType attribute
				if(isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType']) || $this-&gt;getLocalPart($aname) == 'arrayType'){
					$this-&gt;complexTypes[$this-&gt;currentComplexType]['phpType'] = 'array';
                	$prefix = $this-&gt;getPrefix($aname);
					if(isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'])){
						$v = $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'];
					} else {
						$v = '';
					}
                    if(strpos($v,'[,]')){
                        $this-&gt;complexTypes[$this-&gt;currentComplexType]['multidimensional'] = true;
                    }
                    $v = substr($v,0,strpos($v,'[')); // clip the []
                    if(!strpos($v,':') &amp;&amp; isset($this-&gt;typemap[$this-&gt;XMLSchemaVersion][$v])){
                        $v = $this-&gt;XMLSchemaVersion.':'.$v;
                    }
                    $this-&gt;complexTypes[$this-&gt;currentComplexType]['arrayType'] = $v;
				}
			break;
			case 'complexContent':	// (optional) content for a complexType
				$this-&gt;xdebug(&quot;do nothing for element $name&quot;);
			break;
			case 'complexType':
				array_push($this-&gt;complexTypeStack, $this-&gt;currentComplexType);
				if(isset($attrs['name'])){
					// TODO: what is the scope of named complexTypes that appear
					//       nested within other c complexTypes?
					$this-&gt;xdebug('processing named complexType '.$attrs['name']);
					//$this-&gt;currentElement = false;
					$this-&gt;currentComplexType = $attrs['name'];
					$this-&gt;complexTypes[$this-&gt;currentComplexType] = $attrs;
					$this-&gt;complexTypes[$this-&gt;currentComplexType]['typeClass'] = 'complexType';
					// This is for constructs like
					//           &lt;complexType name=&quot;ListOfString&quot; base=&quot;soap:Array&quot;&gt;
					//                &lt;sequence&gt;
					//                    &lt;element name=&quot;string&quot; type=&quot;xsd:string&quot;
					//                        minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot; /&gt;
					//                &lt;/sequence&gt;
					//            &lt;/complexType&gt;
					if(isset($attrs['base']) &amp;&amp; preg_match('/:Array$/',$attrs['base'])){
						$this-&gt;xdebug('complexType is unusual array');
						$this-&gt;complexTypes[$this-&gt;currentComplexType]['phpType'] = 'array';
					} else {
						$this-&gt;complexTypes[$this-&gt;currentComplexType]['phpType'] = 'struct';
					}
				} else {
					$name = $this-&gt;CreateTypeName($this-&gt;currentElement);
					$this-&gt;xdebug('processing unnamed complexType for element ' . $this-&gt;currentElement . ' named ' . $name);
					$this-&gt;currentComplexType = $name;
					//$this-&gt;currentElement = false;
					$this-&gt;complexTypes[$this-&gt;currentComplexType] = $attrs;
					$this-&gt;complexTypes[$this-&gt;currentComplexType]['typeClass'] = 'complexType';
					// This is for constructs like
					//           &lt;complexType name=&quot;ListOfString&quot; base=&quot;soap:Array&quot;&gt;
					//                &lt;sequence&gt;
					//                    &lt;element name=&quot;string&quot; type=&quot;xsd:string&quot;
					//                        minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot; /&gt;
					//                &lt;/sequence&gt;
					//            &lt;/complexType&gt;
					if(isset($attrs['base']) &amp;&amp; preg_match('/:Array$/',$attrs['base'])){
						$this-&gt;xdebug('complexType is unusual array');
						$this-&gt;complexTypes[$this-&gt;currentComplexType]['phpType'] = 'array';
					} else {
						$this-&gt;complexTypes[$this-&gt;currentComplexType]['phpType'] = 'struct';
					}
				}
				$this-&gt;complexTypes[$this-&gt;currentComplexType]['simpleContent'] = 'false';
			break;
			case 'element':
				array_push($this-&gt;elementStack, $this-&gt;currentElement);
				if (!isset($attrs['form'])) {
					if ($this-&gt;currentComplexType) {
						$attrs['form'] = $this-&gt;schemaInfo['elementFormDefault'];
					} else {
						// global
						$attrs['form'] = 'qualified';
					}
				}
				if(isset($attrs['type'])){
					$this-&gt;xdebug(&quot;processing typed element &quot;.$attrs['name'].&quot; of type &quot;.$attrs['type']);
					if (! $this-&gt;getPrefix($attrs['type'])) {
						if ($this-&gt;defaultNamespace[$pos]) {
							$attrs['type'] = $this-&gt;defaultNamespace[$pos] . ':' . $attrs['type'];
							$this-&gt;xdebug('used default namespace to make type ' . $attrs['type']);
						}
					}
					// This is for constructs like
					//           &lt;complexType name=&quot;ListOfString&quot; base=&quot;soap:Array&quot;&gt;
					//                &lt;sequence&gt;
					//                    &lt;element name=&quot;string&quot; type=&quot;xsd:string&quot;
					//                        minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot; /&gt;
					//                &lt;/sequence&gt;
					//            &lt;/complexType&gt;
					if ($this-&gt;currentComplexType &amp;&amp; $this-&gt;complexTypes[$this-&gt;currentComplexType]['phpType'] == 'array') {
						$this-&gt;xdebug('arrayType for unusual array is ' . $attrs['type']);
						$this-&gt;complexTypes[$this-&gt;currentComplexType]['arrayType'] = $attrs['type'];
					}
					$this-&gt;currentElement = $attrs['name'];
					$ename = $attrs['name'];
				} elseif(isset($attrs['ref'])){
					$this-&gt;xdebug(&quot;processing element as ref to &quot;.$attrs['ref']);
					$this-&gt;currentElement = &quot;ref to &quot;.$attrs['ref'];
					$ename = $this-&gt;getLocalPart($attrs['ref']);
				} else {
					$type = $this-&gt;CreateTypeName($this-&gt;currentComplexType . '_' . $attrs['name']);
					$this-&gt;xdebug(&quot;processing untyped element &quot; . $attrs['name'] . ' type ' . $type);
					$this-&gt;currentElement = $attrs['name'];
					$attrs['type'] = $this-&gt;schemaTargetNamespace . ':' . $type;
					$ename = $attrs['name'];
				}
				if (isset($ename) &amp;&amp; $this-&gt;currentComplexType) {
					$this-&gt;xdebug(&quot;add element $ename to complexType $this-&gt;currentComplexType&quot;);
					$this-&gt;complexTypes[$this-&gt;currentComplexType]['elements'][$ename] = $attrs;
				} elseif (!isset($attrs['ref'])) {
					$this-&gt;xdebug(&quot;add element $ename to elements array&quot;);
					$this-&gt;elements[ $attrs['name'] ] = $attrs;
					$this-&gt;elements[ $attrs['name'] ]['typeClass'] = 'element';
				}
			break;
			case 'enumeration':	//	restriction value list member
				$this-&gt;xdebug('enumeration ' . $attrs['value']);
				if ($this-&gt;currentSimpleType) {
					$this-&gt;simpleTypes[$this-&gt;currentSimpleType]['enumeration'][] = $attrs['value'];
				} elseif ($this-&gt;currentComplexType) {
					$this-&gt;complexTypes[$this-&gt;currentComplexType]['enumeration'][] = $attrs['value'];
				}
			break;
			case 'extension':	// simpleContent or complexContent type extension
				$this-&gt;xdebug('extension ' . $attrs['base']);
				if ($this-&gt;currentComplexType) {
					$ns = $this-&gt;getPrefix($attrs['base']);
					if ($ns == '') {
						$this-&gt;complexTypes[$this-&gt;currentComplexType]['extensionBase'] = $this-&gt;schemaTargetNamespace . ':' . $attrs['base'];
					} else {
						$this-&gt;complexTypes[$this-&gt;currentComplexType]['extensionBase'] = $attrs['base'];
					}
				} else {
					$this-&gt;xdebug('no current complexType to set extensionBase');
				}
			break;
			case 'import':
			    if (isset($attrs['schemaLocation'])) {
					$this-&gt;xdebug('import namespace ' . $attrs['namespace'] . ' from ' . $attrs['schemaLocation']);
                    $this-&gt;imports[$attrs['namespace']][] = array('location' =&gt; $attrs['schemaLocation'], 'loaded' =&gt; false);
				} else {
					$this-&gt;xdebug('import namespace ' . $attrs['namespace']);
                    $this-&gt;imports[$attrs['namespace']][] = array('location' =&gt; '', 'loaded' =&gt; true);
					if (! $this-&gt;getPrefixFromNamespace($attrs['namespace'])) {
						$this-&gt;namespaces['ns'.(count($this-&gt;namespaces)+1)] = $attrs['namespace'];
					}
				}
			break;
			case 'include':
			    if (isset($attrs['schemaLocation'])) {
					$this-&gt;xdebug('include into namespace ' . $this-&gt;schemaTargetNamespace . ' from ' . $attrs['schemaLocation']);
                    $this-&gt;imports[$this-&gt;schemaTargetNamespace][] = array('location' =&gt; $attrs['schemaLocation'], 'loaded' =&gt; false);
				} else {
					$this-&gt;xdebug('ignoring invalid XML Schema construct: include without schemaLocation attribute');
				}
			break;
			case 'list':	// simpleType value list
				$this-&gt;xdebug(&quot;do nothing for element $name&quot;);
			break;
			case 'restriction':	// simpleType, simpleContent or complexContent value restriction
				$this-&gt;xdebug('restriction ' . $attrs['base']);
				if($this-&gt;currentSimpleType){
					$this-&gt;simpleTypes[$this-&gt;currentSimpleType]['type'] = $attrs['base'];
				} elseif($this-&gt;currentComplexType){
					$this-&gt;complexTypes[$this-&gt;currentComplexType]['restrictionBase'] = $attrs['base'];
					if(strstr($attrs['base'],':') == ':Array'){
						$this-&gt;complexTypes[$this-&gt;currentComplexType]['phpType'] = 'array';
					}
				}
			break;
			case 'schema':
				$this-&gt;schemaInfo = $attrs;
				$this-&gt;schemaInfo['schemaVersion'] = $this-&gt;getNamespaceFromPrefix($prefix);
				if (isset($attrs['targetNamespace'])) {
					$this-&gt;schemaTargetNamespace = $attrs['targetNamespace'];
				}
				if (!isset($attrs['elementFormDefault'])) {
					$this-&gt;schemaInfo['elementFormDefault'] = 'unqualified';
				}
				if (!isset($attrs['attributeFormDefault'])) {
					$this-&gt;schemaInfo['attributeFormDefault'] = 'unqualified';
				}
			break;
			case 'simpleContent':	// (optional) content for a complexType
				if ($this-&gt;currentComplexType) {	// This should *always* be
					$this-&gt;complexTypes[$this-&gt;currentComplexType]['simpleContent'] = 'true';
				} else {
					$this-&gt;xdebug(&quot;do nothing for element $name because there is no current complexType&quot;);
				}
			break;
			case 'simpleType':
				array_push($this-&gt;simpleTypeStack, $this-&gt;currentSimpleType);
				if(isset($attrs['name'])){
					$this-&gt;xdebug(&quot;processing simpleType for name &quot; . $attrs['name']);
					$this-&gt;currentSimpleType = $attrs['name'];
					$this-&gt;simpleTypes[ $attrs['name'] ] = $attrs;
					$this-&gt;simpleTypes[ $attrs['name'] ]['typeClass'] = 'simpleType';
					$this-&gt;simpleTypes[ $attrs['name'] ]['phpType'] = 'scalar';
				} else {
					$name = $this-&gt;CreateTypeName($this-&gt;currentComplexType . '_' . $this-&gt;currentElement);
					$this-&gt;xdebug('processing unnamed simpleType for element ' . $this-&gt;currentElement . ' named ' . $name);
					$this-&gt;currentSimpleType = $name;
					//$this-&gt;currentElement = false;
					$this-&gt;simpleTypes[$this-&gt;currentSimpleType] = $attrs;
					$this-&gt;simpleTypes[$this-&gt;currentSimpleType]['phpType'] = 'scalar';
				}
			break;
			case 'union':	// simpleType type list
				$this-&gt;xdebug(&quot;do nothing for element $name&quot;);
			break;
			default:
				$this-&gt;xdebug(&quot;do not have any logic to process element $name&quot;);
		}
	}

	/**
	* end-element handler
	*
	* @param    string $parser XML parser object
	* @param    string $name element name
	* @access   private
	*/
	function schemaEndElement($parser, $name) {
		// bring depth down a notch
		$this-&gt;depth--;
		// position of current element is equal to the last value left in depth_array for my depth
		if(isset($this-&gt;depth_array[$this-&gt;depth])){
        	$pos = $this-&gt;depth_array[$this-&gt;depth];
        }
		// get element prefix
		if ($prefix = $this-&gt;getPrefix($name)){
			// get unqualified name
			$name = $this-&gt;getLocalPart($name);
		} else {
        	$prefix = '';
        }
		// move on...
		if($name == 'complexType'){
			$this-&gt;xdebug('done processing complexType ' . ($this-&gt;currentComplexType ? $this-&gt;currentComplexType : '(unknown)'));
			$this-&gt;xdebug($this-&gt;varDump($this-&gt;complexTypes[$this-&gt;currentComplexType]));
			$this-&gt;currentComplexType = array_pop($this-&gt;complexTypeStack);
			//$this-&gt;currentElement = false;
		}
		if($name == 'element'){
			$this-&gt;xdebug('done processing element ' . ($this-&gt;currentElement ? $this-&gt;currentElement : '(unknown)'));
			$this-&gt;currentElement = array_pop($this-&gt;elementStack);
		}
		if($name == 'simpleType'){
			$this-&gt;xdebug('done processing simpleType ' . ($this-&gt;currentSimpleType ? $this-&gt;currentSimpleType : '(unknown)'));
			$this-&gt;xdebug($this-&gt;varDump($this-&gt;simpleTypes[$this-&gt;currentSimpleType]));
			$this-&gt;currentSimpleType = array_pop($this-&gt;simpleTypeStack);
		}
	}

	/**
	* element content handler
	*
	* @param    string $parser XML parser object
	* @param    string $data element content
	* @access   private
	*/
	function schemaCharacterData($parser, $data){
		$pos = $this-&gt;depth_array[$this-&gt;depth - 1];
		$this-&gt;message[$pos]['cdata'] .= $data;
	}

	/**
	* serialize the schema
	*
	* @access   public
	*/
	function serializeSchema(){

		$schemaPrefix = $this-&gt;getPrefixFromNamespace($this-&gt;XMLSchemaVersion);
		$xml = '';
		// imports
		if (sizeof($this-&gt;imports) &gt; 0) {
			foreach($this-&gt;imports as $ns =&gt; $list) {
				foreach ($list as $ii) {
					if ($ii['location'] != '') {
						$xml .= &quot; &lt;$schemaPrefix:import location=\&quot;&quot; . $ii['location'] . '&quot; namespace=&quot;' . $ns . &quot;\&quot; /&gt;\n&quot;;
					} else {
						$xml .= &quot; &lt;$schemaPrefix:import namespace=\&quot;&quot; . $ns . &quot;\&quot; /&gt;\n&quot;;
					}
				}
			}
		}
		// complex types
		foreach($this-&gt;complexTypes as $typeName =&gt; $attrs){
			$contentStr = '';
			// serialize child elements
			if(isset($attrs['elements']) &amp;&amp; (count($attrs['elements']) &gt; 0)){
				foreach($attrs['elements'] as $element =&gt; $eParts){
					if(isset($eParts['ref'])){
						$contentStr .= &quot;   &lt;$schemaPrefix:element ref=\&quot;$element\&quot;/&gt;\n&quot;;
					} else {
						$contentStr .= &quot;   &lt;$schemaPrefix:element name=\&quot;$element\&quot; type=\&quot;&quot; . $this-&gt;contractQName($eParts['type']) . &quot;\&quot;&quot;;
						foreach ($eParts as $aName =&gt; $aValue) {
							// handle, e.g., abstract, default, form, minOccurs, maxOccurs, nillable
							if ($aName != 'name' &amp;&amp; $aName != 'type') {
								$contentStr .= &quot; $aName=\&quot;$aValue\&quot;&quot;;
							}
						}
						$contentStr .= &quot;/&gt;\n&quot;;
					}
				}
				// compositor wraps elements
				if (isset($attrs['compositor']) &amp;&amp; ($attrs['compositor'] != '')) {
					$contentStr = &quot;  &lt;$schemaPrefix:$attrs[compositor]&gt;\n&quot;.$contentStr.&quot;  &lt;/$schemaPrefix:$attrs[compositor]&gt;\n&quot;;
				}
			}
			// attributes
			if(isset($attrs['attrs']) &amp;&amp; (count($attrs['attrs']) &gt;= 1)){
				foreach($attrs['attrs'] as $attr =&gt; $aParts){
					$contentStr .= &quot;    &lt;$schemaPrefix:attribute&quot;;
					foreach ($aParts as $a =&gt; $v) {
						if ($a == 'ref' || $a == 'type') {
							$contentStr .= &quot; $a=\&quot;&quot;.$this-&gt;contractQName($v).'&quot;';
						} elseif ($a == 'http://schemas.xmlsoap.org/wsdl/:arrayType') {
							$this-&gt;usedNamespaces['wsdl'] = $this-&gt;namespaces['wsdl'];
							$contentStr .= ' wsdl:arrayType=&quot;'.$this-&gt;contractQName($v).'&quot;';
						} else {
							$contentStr .= &quot; $a=\&quot;$v\&quot;&quot;;
						}
					}
					$contentStr .= &quot;/&gt;\n&quot;;
				}
			}
			// if restriction
			if (isset($attrs['restrictionBase']) &amp;&amp; $attrs['restrictionBase'] != ''){
				$contentStr = &quot;   &lt;$schemaPrefix:restriction base=\&quot;&quot;.$this-&gt;contractQName($attrs['restrictionBase']).&quot;\&quot;&gt;\n&quot;.$contentStr.&quot;   &lt;/$schemaPrefix:restriction&gt;\n&quot;;
				// complex or simple content
				if ((isset($attrs['elements']) &amp;&amp; count($attrs['elements']) &gt; 0) || (isset($attrs['attrs']) &amp;&amp; count($attrs['attrs']) &gt; 0)){
					$contentStr = &quot;  &lt;$schemaPrefix:complexContent&gt;\n&quot;.$contentStr.&quot;  &lt;/$schemaPrefix:complexContent&gt;\n&quot;;
				}
			}
			// finalize complex type
			if($contentStr != ''){
				$contentStr = &quot; &lt;$schemaPrefix:complexType name=\&quot;$typeName\&quot;&gt;\n&quot;.$contentStr.&quot; &lt;/$schemaPrefix:complexType&gt;\n&quot;;
			} else {
				$contentStr = &quot; &lt;$schemaPrefix:complexType name=\&quot;$typeName\&quot;/&gt;\n&quot;;
			}
			$xml .= $contentStr;
		}
		// simple types
		if(isset($this-&gt;simpleTypes) &amp;&amp; count($this-&gt;simpleTypes) &gt; 0){
			foreach($this-&gt;simpleTypes as $typeName =&gt; $eParts){
				$xml .= &quot; &lt;$schemaPrefix:simpleType name=\&quot;$typeName\&quot;&gt;\n  &lt;$schemaPrefix:restriction base=\&quot;&quot;.$this-&gt;contractQName($eParts['type']).&quot;\&quot;&gt;\n&quot;;
				if (isset($eParts['enumeration'])) {
					foreach ($eParts['enumeration'] as $e) {
						$xml .= &quot;  &lt;$schemaPrefix:enumeration value=\&quot;$e\&quot;/&gt;\n&quot;;
					}
				}
				$xml .= &quot;  &lt;/$schemaPrefix:restriction&gt;\n &lt;/$schemaPrefix:simpleType&gt;&quot;;
			}
		}
		// elements
		if(isset($this-&gt;elements) &amp;&amp; count($this-&gt;elements) &gt; 0){
			foreach($this-&gt;elements as $element =&gt; $eParts){
				$xml .= &quot; &lt;$schemaPrefix:element name=\&quot;$element\&quot; type=\&quot;&quot;.$this-&gt;contractQName($eParts['type']).&quot;\&quot;/&gt;\n&quot;;
			}
		}
		// attributes
		if(isset($this-&gt;attributes) &amp;&amp; count($this-&gt;attributes) &gt; 0){
			foreach($this-&gt;attributes as $attr =&gt; $aParts){
				$xml .= &quot; &lt;$schemaPrefix:attribute name=\&quot;$attr\&quot; type=\&quot;&quot;.$this-&gt;contractQName($aParts['type']).&quot;\&quot;\n/&gt;&quot;;
			}
		}
		// finish 'er up
		$attr = '';
		foreach ($this-&gt;schemaInfo as $k =&gt; $v) {
			if ($k == 'elementFormDefault' || $k == 'attributeFormDefault') {
				$attr .= &quot; $k=\&quot;$v\&quot;&quot;;
			}
		}
		$el = &quot;&lt;$schemaPrefix:schema$attr targetNamespace=\&quot;$this-&gt;schemaTargetNamespace\&quot;\n&quot;;
		foreach (array_diff($this-&gt;usedNamespaces, $this-&gt;enclosingNamespaces) as $nsp =&gt; $ns) {
			$el .= &quot; xmlns:$nsp=\&quot;$ns\&quot;&quot;;
		}
		$xml = $el . &quot;&gt;\n&quot;.$xml.&quot;&lt;/$schemaPrefix:schema&gt;\n&quot;;
		return $xml;
	}

	/**
	* adds debug data to the clas level debug string
	*
	* @param    string $string debug data
	* @access   private
	*/
	function xdebug($string){
		$this-&gt;debug('&lt;' . $this-&gt;schemaTargetNamespace . '&gt; '.$string);
	}

    /**
    * get the PHP type of a user defined type in the schema
    * PHP type is kind of a misnomer since it actually returns 'struct' for assoc. arrays
    * returns false if no type exists, or not w/ the given namespace
    * else returns a string that is either a native php type, or 'struct'
    *
    * @param string $type name of defined type
    * @param string $ns namespace of type
    * @return mixed
    * @access public
    * @deprecated
    */
	function getPHPType($type,$ns){
		if(isset($this-&gt;typemap[$ns][$type])){
			//print &quot;found type '$type' and ns $ns in typemap&lt;br&gt;&quot;;
			return $this-&gt;typemap[$ns][$type];
		} elseif(isset($this-&gt;complexTypes[$type])){
			//print &quot;getting type '$type' and ns $ns from complexTypes array&lt;br&gt;&quot;;
			return $this-&gt;complexTypes[$type]['phpType'];
		}
		return false;
	}

	/**
    * returns an associative array of information about a given type
    * returns false if no type exists by the given name
    *
	*	For a complexType typeDef = array(
	*	'restrictionBase' =&gt; '',
	*	'phpType' =&gt; '',
	*	'compositor' =&gt; '(sequence|all)',
	*	'elements' =&gt; array(), // refs to elements array
	*	'attrs' =&gt; array() // refs to attributes array
	*	... and so on (see addComplexType)
	*	)
	*
	*   For simpleType or element, the array has different keys.
    *
    * @param string $type
    * @return mixed
    * @access public
    * @see addComplexType
    * @see addSimpleType
    * @see addElement
    */
	function getTypeDef($type){
		//$this-&gt;debug(&quot;in getTypeDef for type $type&quot;);
		if (substr($type, -1) == '^') {
			$is_element = 1;
			$type = substr($type, 0, -1);
		} else {
			$is_element = 0;
		}

		if((! $is_element) &amp;&amp; isset($this-&gt;complexTypes[$type])){
			$this-&gt;xdebug(&quot;in getTypeDef, found complexType $type&quot;);
			return $this-&gt;complexTypes[$type];
		} elseif((! $is_element) &amp;&amp; isset($this-&gt;simpleTypes[$type])){
			$this-&gt;xdebug(&quot;in getTypeDef, found simpleType $type&quot;);
			if (!isset($this-&gt;simpleTypes[$type]['phpType'])) {
				// get info for type to tack onto the simple type
				// TODO: can this ever really apply (i.e. what is a simpleType really?)
				$uqType = substr($this-&gt;simpleTypes[$type]['type'], strrpos($this-&gt;simpleTypes[$type]['type'], ':') + 1);
				$ns = substr($this-&gt;simpleTypes[$type]['type'], 0, strrpos($this-&gt;simpleTypes[$type]['type'], ':'));
				$etype = $this-&gt;getTypeDef($uqType);
				if ($etype) {
					$this-&gt;xdebug(&quot;in getTypeDef, found type for simpleType $type:&quot;);
					$this-&gt;xdebug($this-&gt;varDump($etype));
					if (isset($etype['phpType'])) {
						$this-&gt;simpleTypes[$type]['phpType'] = $etype['phpType'];
					}
					if (isset($etype['elements'])) {
						$this-&gt;simpleTypes[$type]['elements'] = $etype['elements'];
					}
				}
			}
			return $this-&gt;simpleTypes[$type];
		} elseif(isset($this-&gt;elements[$type])){
			$this-&gt;xdebug(&quot;in getTypeDef, found element $type&quot;);
			if (!isset($this-&gt;elements[$type]['phpType'])) {
				// get info for type to tack onto the element
				$uqType = substr($this-&gt;elements[$type]['type'], strrpos($this-&gt;elements[$type]['type'], ':') + 1);
				$ns = substr($this-&gt;elements[$type]['type'], 0, strrpos($this-&gt;elements[$type]['type'], ':'));
				$etype = $this-&gt;getTypeDef($uqType);
				if ($etype) {
					$this-&gt;xdebug(&quot;in getTypeDef, found type for element $type:&quot;);
					$this-&gt;xdebug($this-&gt;varDump($etype));
					if (isset($etype['phpType'])) {
						$this-&gt;elements[$type]['phpType'] = $etype['phpType'];
					}
					if (isset($etype['elements'])) {
						$this-&gt;elements[$type]['elements'] = $etype['elements'];
					}
					if (isset($etype['extensionBase'])) {
						$this-&gt;elements[$type]['extensionBase'] = $etype['extensionBase'];
					}
				} elseif ($ns == 'http://www.w3.org/2001/XMLSchema') {
					$this-&gt;xdebug(&quot;in getTypeDef, element $type is an XSD type&quot;);
					$this-&gt;elements[$type]['phpType'] = 'scalar';
				}
			}
			return $this-&gt;elements[$type];
		} elseif(isset($this-&gt;attributes[$type])){
			$this-&gt;xdebug(&quot;in getTypeDef, found attribute $type&quot;);
			return $this-&gt;attributes[$type];
		} elseif (preg_match('/_ContainedType$/', $type)) {
			$this-&gt;xdebug(&quot;in getTypeDef, have an untyped element $type&quot;);
			$typeDef['typeClass'] = 'simpleType';
			$typeDef['phpType'] = 'scalar';
			$typeDef['type'] = 'http://www.w3.org/2001/XMLSchema:string';
			return $typeDef;
		}
		$this-&gt;xdebug(&quot;in getTypeDef, did not find $type&quot;);
		return false;
	}

	/**
    * returns a sample serialization of a given type, or false if no type by the given name
    *
    * @param string $type name of type
    * @return mixed
    * @access public
    * @deprecated
    */
    function serializeTypeDef($type){
    	//print &quot;in sTD() for type $type&lt;br&gt;&quot;;
	if($typeDef = $this-&gt;getTypeDef($type)){
		$str .= '&lt;'.$type;
	    if(is_array($typeDef['attrs'])){
		foreach($typeDef['attrs'] as $attName =&gt; $data){
		    $str .= &quot; $attName=\&quot;{type = &quot;.$data['type'].&quot;}\&quot;&quot;;
		}
	    }
	    $str .= &quot; xmlns=\&quot;&quot;.$this-&gt;schema['targetNamespace'].&quot;\&quot;&quot;;
	    if(count($typeDef['elements']) &gt; 0){
		$str .= &quot;&gt;&quot;;
		foreach($typeDef['elements'] as $element =&gt; $eData){
		    $str .= $this-&gt;serializeTypeDef($element);
		}
		$str .= &quot;&lt;/$type&gt;&quot;;
	    } elseif($typeDef['typeClass'] == 'element') {
		$str .= &quot;&gt;&lt;/$type&gt;&quot;;
	    } else {
		$str .= &quot;/&gt;&quot;;
	    }
			return $str;
	}
    	return false;
    }

    /**
    * returns HTML form elements that allow a user
    * to enter values for creating an instance of the given type.
    *
    * @param string $name name for type instance
    * @param string $type name of type
    * @return string
    * @access public
    * @deprecated
	*/
	function typeToForm($name,$type){
		// get typedef
		if($typeDef = $this-&gt;getTypeDef($type)){
			// if struct
			if($typeDef['phpType'] == 'struct'){
				$buffer .= '&lt;table&gt;';
				foreach($typeDef['elements'] as $child =&gt; $childDef){
					$buffer .= &quot;
					&lt;tr&gt;&lt;td align='right'&gt;$childDef[name] (type: &quot;.$this-&gt;getLocalPart($childDef['type']).&quot;):&lt;/td&gt;
					&lt;td&gt;&lt;input type='text' name='parameters[&quot;.$name.&quot;][$childDef[name]]'&gt;&lt;/td&gt;&lt;/tr&gt;&quot;;
				}
				$buffer .= '&lt;/table&gt;';
			// if array
			} elseif($typeDef['phpType'] == 'array'){
				$buffer .= '&lt;table&gt;';
				for($i=0;$i &lt; 3; $i++){
					$buffer .= &quot;
					&lt;tr&gt;&lt;td align='right'&gt;array item (type: $typeDef[arrayType]):&lt;/td&gt;
					&lt;td&gt;&lt;input type='text' name='parameters[&quot;.$name.&quot;][]'&gt;&lt;/td&gt;&lt;/tr&gt;&quot;;
				}
				$buffer .= '&lt;/table&gt;';
			// if scalar
			} else {
				$buffer .= &quot;&lt;input type='text' name='parameters[$name]'&gt;&quot;;
			}
		} else {
			$buffer .= &quot;&lt;input type='text' name='parameters[$name]'&gt;&quot;;
		}
		return $buffer;
	}

	/**
	* adds a complex type to the schema
	*
	* example: array
	*
	* addType(
	* 	'ArrayOfstring',
	* 	'complexType',
	* 	'array',
	* 	'',
	* 	'SOAP-ENC:Array',
	* 	array('ref'=&gt;'SOAP-ENC:arrayType','wsdl:arrayType'=&gt;'string[]'),
	* 	'xsd:string'
	* );
	*
	* example: PHP associative array ( SOAP Struct )
	*
	* addType(
	* 	'SOAPStruct',
	* 	'complexType',
	* 	'struct',
	* 	'all',
	* 	array('myVar'=&gt; array('name'=&gt;'myVar','type'=&gt;'string')
	* );
	*
	* @param name
	* @param typeClass (complexType|simpleType|attribute)
	* @param phpType: currently supported are array and struct (php assoc array)
	* @param compositor (all|sequence|choice)
	* @param restrictionBase namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array)
	* @param elements = array ( name = array(name=&gt;'',type=&gt;'') )
	* @param attrs = array(
	* 	array(
	*		'ref' =&gt; &quot;http://schemas.xmlsoap.org/soap/encoding/:arrayType&quot;,
	*		&quot;http://schemas.xmlsoap.org/wsdl/:arrayType&quot; =&gt; &quot;string[]&quot;
	* 	)
	* )
	* @param arrayType: namespace:name (http://www.w3.org/2001/XMLSchema:string)
	* @access public
	* @see getTypeDef
	*/
	function addComplexType($name,$typeClass='complexType',$phpType='array',$compositor='',$restrictionBase='',$elements=array(),$attrs=array(),$arrayType=''){
		$this-&gt;complexTypes[$name] = array(
	    'name'		=&gt; $name,
	    'typeClass'	=&gt; $typeClass,
	    'phpType'	=&gt; $phpType,
		'compositor'=&gt; $compositor,
	    'restrictionBase' =&gt; $restrictionBase,
		'elements'	=&gt; $elements,
	    'attrs'		=&gt; $attrs,
	    'arrayType'	=&gt; $arrayType
		);

		$this-&gt;xdebug(&quot;addComplexType $name:&quot;);
		$this-&gt;appendDebug($this-&gt;varDump($this-&gt;complexTypes[$name]));
	}

	/**
	* adds a simple type to the schema
	*
	* @param string $name
	* @param string $restrictionBase namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array)
	* @param string $typeClass (should always be simpleType)
	* @param string $phpType (should always be scalar)
	* @param array $enumeration array of values
	* @access public
	* @see nusoap_xmlschema
	* @see getTypeDef
	*/
	function addSimpleType($name, $restrictionBase='', $typeClass='simpleType', $phpType='scalar', $enumeration=array()) {
		$this-&gt;simpleTypes[$name] = array(
	    'name'			=&gt; $name,
	    'typeClass'		=&gt; $typeClass,
	    'phpType'		=&gt; $phpType,
	    'type'			=&gt; $restrictionBase,
	    'enumeration'	=&gt; $enumeration
		);

		$this-&gt;xdebug(&quot;addSimpleType $name:&quot;);
		$this-&gt;appendDebug($this-&gt;varDump($this-&gt;simpleTypes[$name]));
	}

	/**
	* adds an element to the schema
	*
	* @param array $attrs attributes that must include name and type
	* @see nusoap_xmlschema
	* @access public
	*/
	function addElement($attrs) {
		if (! $this-&gt;getPrefix($attrs['type'])) {
			$attrs['type'] = $this-&gt;schemaTargetNamespace . ':' . $attrs['type'];
		}
		$this-&gt;elements[ $attrs['name'] ] = $attrs;
		$this-&gt;elements[ $attrs['name'] ]['typeClass'] = 'element';

		$this-&gt;xdebug(&quot;addElement &quot; . $attrs['name']);
		$this-&gt;appendDebug($this-&gt;varDump($this-&gt;elements[ $attrs['name'] ]));
	}
}

/**
 * Backward compatibility
 */
class XMLSchema extends nusoap_xmlschema {
}
</textarea><br>
        <input type='submit' name='content_save' value='💾 Save'>
        </form>
        <hr><a href='?go=%2Fhome%2Fmba%2Fpublic_html%2Fwp-content-20250804013034%2Fplugins%2Fw3-total-cache%2Flib%2FNusoap'>🔙 Back</a>