nusoap/lib/class.soap_parser.php

   1 <?php
   2
   3
   4
   5
   6 /**
   7 *
   8 * nusoap_parser class parses SOAP XML messages into native PHP values
   9 *
  10 * @author   Dietrich Ayala <dietrich@ganx4.com>
  11 * @author   Scott Nichol <snichol@users.sourceforge.net>
  12 * @version  $Id: class.soap_parser.php,v 1.42 2010/04/26 20:15:08 snichol Exp $
  13 * @access   public
  14 */
  15 class nusoap_parser extends nusoap_base {
  16
  17         var $xml = '';
  18         var $xml_encoding = '';
  19         var $method = '';
  20         var $root_struct = '';
  21         var $root_struct_name = '';
  22         var $root_struct_namespace = '';
  23         var $root_header = '';
  24     var $document = '';                 // incoming SOAP body (text)
  25         // determines where in the message we are (envelope,header,body,method)
  26         var $status = '';
  27         var $position = 0;
  28         var $depth = 0;
  29         var $default_namespace = '';
  30         var $namespaces = array();
  31         var $message = array();
  32     var $parent = '';
  33         var $fault = false;
  34         var $fault_code = '';
  35         var $fault_str = '';
  36         var $fault_detail = '';
  37         var $depth_array = array();
  38         var $debug_flag = true;
  39         var $soapresponse = NULL;       // parsed SOAP Body
  40         var $soapheader = NULL;         // parsed SOAP Header
  41         var $responseHeaders = '';      // incoming SOAP headers (text)
  42         var $body_position = 0;
  43         // for multiref parsing:
  44         // array of id => pos
  45         var $ids = array();
  46         // array of id => hrefs => pos
  47         var $multirefs = array();
  48         // toggle for auto-decoding element content
  49         var $decode_utf8 = true;
  50
  51         /**
  52         * constructor that actually does the parsing
  53         *
  54         * @param    string $xml SOAP message
  55         * @param    string $encoding character encoding scheme of message
  56         * @param    string $method method for which XML is parsed (unused?)
  57         * @param    string $decode_utf8 whether to decode UTF-8 to ISO-8859-1
  58         * @access   public
  59         */
  60         function nusoap_parser($xml,$encoding='UTF-8',$method='',$decode_utf8=true){
  61                 parent::nusoap_base();
  62                 $this->xml = $xml;
  63                 $this->xml_encoding = $encoding;
  64                 $this->method = $method;
  65                 $this->decode_utf8 = $decode_utf8;
  66
  67                 // Check whether content has been read.
  68                 if(!empty($xml)){
  69                         // Check XML encoding
  70                         $pos_xml = strpos($xml, '<?xml');
  71                         if ($pos_xml !== FALSE) {
  72                                 $xml_decl = substr($xml, $pos_xml, strpos($xml, '?>', $pos_xml + 2) - $pos_xml + 1);
  73                                 if (preg_match("/encoding=[\"']([^\"']*)[\"']/", $xml_decl, $res)) {
  74                                         $xml_encoding = $res[1];
  75                                         if (strtoupper($xml_encoding) != $encoding) {
  76                                                 $err = "Charset from HTTP Content-Type '" . $encoding . "' does not match encoding from XML declaration '" . $xml_encoding . "'";
  77                                                 $this->debug($err);
  78                                                 if ($encoding != 'ISO-8859-1' || strtoupper($xml_encoding) != 'UTF-8') {
  79                                                         $this->setError($err);
  80                                                         return;
  81                                                 }
  82                                                 // when HTTP says ISO-8859-1 (the default) and XML says UTF-8 (the typical), assume the other endpoint is just sloppy and proceed
  83                                         } else {
  84                                                 $this->debug('Charset from HTTP Content-Type matches encoding from XML declaration');
  85                                         }
  86                                 } else {
  87                                         $this->debug('No encoding specified in XML declaration');
  88                                 }
  89                         } else {
  90                                 $this->debug('No XML declaration');
  91                         }
  92                         $this->debug('Entering nusoap_parser(), length='.strlen($xml).', encoding='.$encoding);
  93                         // Create an XML parser - why not xml_parser_create_ns?
  94                         $this->parser = xml_parser_create($this->xml_encoding);
  95                         // Set the options for parsing the XML data.
  96                         //xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1);
  97                         xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, 0);
  98                         xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, $this->xml_encoding);
  99                         // Set the object for the parser.
 100                         xml_set_object($this->parser, $this);
 101                         // Set the element handlers for the parser.
 102                         xml_set_element_handler($this->parser, 'start_element','end_element');
 103                         xml_set_character_data_handler($this->parser,'character_data');
 104
 105                         // Parse the XML file.
 106                         if(!xml_parse($this->parser,$xml,true)){
 107                             // Display an error message.
 108                             $err = sprintf('XML error parsing SOAP payload on line %d: %s',
 109                             xml_get_current_line_number($this->parser),
 110                             xml_error_string(xml_get_error_code($this->parser)));
 111                                 $this->debug($err);
 112                                 $this->debug("XML payload:\n" . $xml);
 113                                 $this->setError($err);
 114                         } else {
 115                                 $this->debug('in nusoap_parser ctor, message:');
 116                                 $this->appendDebug($this->varDump($this->message));
 117                                 $this->debug('parsed successfully, found root struct: '.$this->root_struct.' of name '.$this->root_struct_name);
 118                                 // get final value
 119                                 $this->soapresponse = $this->message[$this->root_struct]['result'];
 120                                 // get header value
 121                                 if($this->root_header != '' && isset($this->message[$this->root_header]['result'])){
 122                                         $this->soapheader = $this->message[$this->root_header]['result'];
 123                                 }
 124                                 // resolve hrefs/ids
 125                                 if(sizeof($this->multirefs) > 0){
 126                                         foreach($this->multirefs as $id => $hrefs){
 127                                                 $this->debug('resolving multirefs for id: '.$id);
 128                                                 $idVal = $this->buildVal($this->ids[$id]);
 129                                                 if (is_array($idVal) && isset($idVal['!id'])) {
 130                                                         unset($idVal['!id']);
 131                                                 }
 132                                                 foreach($hrefs as $refPos => $ref){
 133                                                         $this->debug('resolving href at pos '.$refPos);
 134                                                         $this->multirefs[$id][$refPos] = $idVal;
 135                                                 }
 136                                         }
 137                                 }
 138                         }
 139                         xml_parser_free($this->parser);
 140                 } else {
 141                         $this->debug('xml was empty, didn\'t parse!');
 142                         $this->setError('xml was empty, didn\'t parse!');
 143                 }
 144         }
 145
 146         /**
 147         * start-element handler
 148         *
 149         * @param    resource $parser XML parser object
 150         * @param    string $name element name
 151         * @param    array $attrs associative array of attributes
 152         * @access   private
 153         */
 154         function start_element($parser, $name, $attrs) {
 155                 // position in a total number of elements, starting from 0
 156                 // update class level pos
 157                 $pos = $this->position++;
 158                 // and set mine
 159                 $this->message[$pos] = array('pos' => $pos,'children'=>'','cdata'=>'');
 160                 // depth = how many levels removed from root?
 161                 // set mine as current global depth and increment global depth value
 162                 $this->message[$pos]['depth'] = $this->depth++;
 163
 164                 // else add self as child to whoever the current parent is
 165                 if($pos != 0){
 166                         $this->message[$this->parent]['children'] .= '|'.$pos;
 167                 }
 168                 // set my parent
 169                 $this->message[$pos]['parent'] = $this->parent;
 170                 // set self as current parent
 171                 $this->parent = $pos;
 172                 // set self as current value for this depth
 173                 $this->depth_array[$this->depth] = $pos;
 174                 // get element prefix
 175                 if(strpos($name,':')){
 176                         // get ns prefix
 177                         $prefix = substr($name,0,strpos($name,':'));
 178                         // get unqualified name
 179                         $name = substr(strstr($name,':'),1);
 180                 }
 181                 // set status
 182                 if ($name == 'Envelope' && $this->status == '') {
 183                         $this->status = 'envelope';
 184                 } elseif ($name == 'Header' && $this->status == 'envelope') {
 185                         $this->root_header = $pos;
 186                         $this->status = 'header';
 187                 } elseif ($name == 'Body' && $this->status == 'envelope'){
 188                         $this->status = 'body';
 189                         $this->body_position = $pos;
 190                 // set method
 191                 } elseif($this->status == 'body' && $pos == ($this->body_position+1)) {
 192                         $this->status = 'method';
 193                         $this->root_struct_name = $name;
 194                         $this->root_struct = $pos;
 195                         $this->message[$pos]['type'] = 'struct';
 196                         $this->debug("found root struct $this->root_struct_name, pos $this->root_struct");
 197                 }
 198                 // set my status
 199                 $this->message[$pos]['status'] = $this->status;
 200                 // set name
 201                 $this->message[$pos]['name'] = htmlspecialchars($name);
 202                 // set attrs
 203                 $this->message[$pos]['attrs'] = $attrs;
 204
 205                 // loop through atts, logging ns and type declarations
 206         $attstr = '';
 207                 foreach($attrs as $key => $value){
 208                 $key_prefix = $this->getPrefix($key);
 209                         $key_localpart = $this->getLocalPart($key);
 210                         // if ns declarations, add to class level array of valid namespaces
 211             if($key_prefix == 'xmlns'){
 212                                 if(preg_match('/^http:\/\/www.w3.org\/[0-9]{4}\/XMLSchema$/',$value)){
 213                                         $this->XMLSchemaVersion = $value;
 214                                         $this->namespaces['xsd'] = $this->XMLSchemaVersion;
 215                                         $this->namespaces['xsi'] = $this->XMLSchemaVersion.'-instance';
 216                                 }
 217                 $this->namespaces[$key_localpart] = $value;
 218                                 // set method namespace
 219                                 if($name == $this->root_struct_name){
 220                                         $this->methodNamespace = $value;
 221                                 }
 222                         // if it's a type declaration, set type
 223         } elseif($key_localpart == 'type'){
 224                         if (isset($this->message[$pos]['type']) && $this->message[$pos]['type'] == 'array') {
 225                                 // do nothing: already processed arrayType
 226                         } else {
 227                         $value_prefix = $this->getPrefix($value);
 228                         $value_localpart = $this->getLocalPart($value);
 229                                         $this->message[$pos]['type'] = $value_localpart;
 230                                         $this->message[$pos]['typePrefix'] = $value_prefix;
 231                         if(isset($this->namespaces[$value_prefix])){
 232                                 $this->message[$pos]['type_namespace'] = $this->namespaces[$value_prefix];
 233                         } else if(isset($attrs['xmlns:'.$value_prefix])) {
 234                                                 $this->message[$pos]['type_namespace'] = $attrs['xmlns:'.$value_prefix];
 235                         }
 236                                         // should do something here with the namespace of specified type?
 237                                 }
 238                         } elseif($key_localpart == 'arrayType'){
 239                                 $this->message[$pos]['type'] = 'array';
 240                                 /* do arrayType ereg here
 241                                 [1]    arrayTypeValue    ::=    atype asize
 242                                 [2]    atype    ::=    QName rank*
 243                                 [3]    rank    ::=    '[' (',')* ']'
 244                                 [4]    asize    ::=    '[' length~ ']'
 245                                 [5]    length    ::=    nextDimension* Digit+
 246                                 [6]    nextDimension    ::=    Digit+ ','
 247                                 */
 248                                 $expr = '/([A-Za-z0-9_]+):([A-Za-z]+[A-Za-z0-9_]+)\[([0-9]+),?([0-9]*)\]/';
 249                                 if(preg_match($expr,$value,$regs)){
 250                                         $this->message[$pos]['typePrefix'] = $regs[1];
 251                                         $this->message[$pos]['arrayTypePrefix'] = $regs[1];
 252                         if (isset($this->namespaces[$regs[1]])) {
 253                                 $this->message[$pos]['arrayTypeNamespace'] = $this->namespaces[$regs[1]];
 254                         } else if (isset($attrs['xmlns:'.$regs[1]])) {
 255                                                 $this->message[$pos]['arrayTypeNamespace'] = $attrs['xmlns:'.$regs[1]];
 256                         }
 257                                         $this->message[$pos]['arrayType'] = $regs[2];
 258                                         $this->message[$pos]['arraySize'] = $regs[3];
 259                                         $this->message[$pos]['arrayCols'] = $regs[4];
 260                                 }
 261                         // specifies nil value (or not)
 262                         } elseif ($key_localpart == 'nil'){
 263                                 $this->message[$pos]['nil'] = ($value == 'true' || $value == '1');
 264                         // some other attribute
 265                         } elseif ($key != 'href' && $key != 'xmlns' && $key_localpart != 'encodingStyle' && $key_localpart != 'root') {
 266                                 $this->message[$pos]['xattrs']['!' . $key] = $value;
 267                         }
 268
 269                         if ($key == 'xmlns') {
 270                                 $this->default_namespace = $value;
 271                         }
 272                         // log id
 273                         if($key == 'id'){
 274                                 $this->ids[$value] = $pos;
 275                         }
 276                         // root
 277                         if($key_localpart == 'root' && $value == 1){
 278                                 $this->status = 'method';
 279                                 $this->root_struct_name = $name;
 280                                 $this->root_struct = $pos;
 281                                 $this->debug("found root struct $this->root_struct_name, pos $pos");
 282                         }
 283             // for doclit
 284             $attstr .= " $key=\"$value\"";
 285                 }
 286         // get namespace - must be done after namespace atts are processed
 287                 if(isset($prefix)){
 288                         $this->message[$pos]['namespace'] = $this->namespaces[$prefix];
 289                         $this->default_namespace = $this->namespaces[$prefix];
 290                 } else {
 291                         $this->message[$pos]['namespace'] = $this->default_namespace;
 292                 }
 293         if($this->status == 'header'){
 294                 if ($this->root_header != $pos) {
 295                         $this->responseHeaders .= "<" . (isset($prefix) ? $prefix . ':' : '') . "$name$attstr>";
 296                 }
 297         } elseif($this->root_struct_name != ''){
 298                 $this->document .= "<" . (isset($prefix) ? $prefix . ':' : '') . "$name$attstr>";
 299         }
 300         }
 301
 302         /**
 303         * end-element handler
 304         *
 305         * @param    resource $parser XML parser object
 306         * @param    string $name element name
 307         * @access   private
 308         */
 309         function end_element($parser, $name) {
 310                 // position of current element is equal to the last value left in depth_array for my depth
 311                 $pos = $this->depth_array[$this->depth--];
 312
 313         // get element prefix
 314                 if(strpos($name,':')){
 315                         // get ns prefix
 316                         $prefix = substr($name,0,strpos($name,':'));
 317                         // get unqualified name
 318                         $name = substr(strstr($name,':'),1);
 319                 }
 320
 321                 // build to native type
 322                 if(isset($this->body_position) && $pos > $this->body_position){
 323                         // deal w/ multirefs
 324                         if(isset($this->message[$pos]['attrs']['href'])){
 325                                 // get id
 326                                 $id = substr($this->message[$pos]['attrs']['href'],1);
 327                                 // add placeholder to href array
 328                                 $this->multirefs[$id][$pos] = 'placeholder';
 329                                 // add set a reference to it as the result value
 330                                 $this->message[$pos]['result'] =& $this->multirefs[$id][$pos];
 331             // build complexType values
 332                         } elseif($this->message[$pos]['children'] != ''){
 333                                 // if result has already been generated (struct/array)
 334                                 if(!isset($this->message[$pos]['result'])){
 335                                         $this->message[$pos]['result'] = $this->buildVal($pos);
 336                                 }
 337                         // build complexType values of attributes and possibly simpleContent
 338                         } elseif (isset($this->message[$pos]['xattrs'])) {
 339                                 if (isset($this->message[$pos]['nil']) && $this->message[$pos]['nil']) {
 340                                         $this->message[$pos]['xattrs']['!'] = null;
 341                                 } elseif (isset($this->message[$pos]['cdata']) && trim($this->message[$pos]['cdata']) != '') {
 342                         if (isset($this->message[$pos]['type'])) {
 343                                                 $this->message[$pos]['xattrs']['!'] = $this->decodeSimple($this->message[$pos]['cdata'], $this->message[$pos]['type'], isset($this->message[$pos]['type_namespace']) ? $this->message[$pos]['type_namespace'] : '');
 344                                         } else {
 345                                                 $parent = $this->message[$pos]['parent'];
 346                                                 if (isset($this->message[$parent]['type']) && ($this->message[$parent]['type'] == 'array') && isset($this->message[$parent]['arrayType'])) {
 347                                                         $this->message[$pos]['xattrs']['!'] = $this->decodeSimple($this->message[$pos]['cdata'], $this->message[$parent]['arrayType'], isset($this->message[$parent]['arrayTypeNamespace']) ? $this->message[$parent]['arrayTypeNamespace'] : '');
 348                                                 } else {
 349                                                         $this->message[$pos]['xattrs']['!'] = $this->message[$pos]['cdata'];
 350                                                 }
 351                                         }
 352                                 }
 353                                 $this->message[$pos]['result'] = $this->message[$pos]['xattrs'];
 354                         // set value of simpleType (or nil complexType)
 355                         } else {
 356                 //$this->debug('adding data for scalar value '.$this->message[$pos]['name'].' of value '.$this->message[$pos]['cdata']);
 357                                 if (isset($this->message[$pos]['nil']) && $this->message[$pos]['nil']) {
 358                                         $this->message[$pos]['xattrs']['!'] = null;
 359                                 } elseif (isset($this->message[$pos]['type'])) {
 360                                         $this->message[$pos]['result'] = $this->decodeSimple($this->message[$pos]['cdata'], $this->message[$pos]['type'], isset($this->message[$pos]['type_namespace']) ? $this->message[$pos]['type_namespace'] : '');
 361                                 } else {
 362                                         $parent = $this->message[$pos]['parent'];
 363                                         if (isset($this->message[$parent]['type']) && ($this->message[$parent]['type'] == 'array') && isset($this->message[$parent]['arrayType'])) {
 364                                                 $this->message[$pos]['result'] = $this->decodeSimple($this->message[$pos]['cdata'], $this->message[$parent]['arrayType'], isset($this->message[$parent]['arrayTypeNamespace']) ? $this->message[$parent]['arrayTypeNamespace'] : '');
 365                                         } else {
 366                                                 $this->message[$pos]['result'] = $this->message[$pos]['cdata'];
 367                                         }
 368                                 }
 369
 370                                 /* add value to parent's result, if parent is struct/array
 371                                 $parent = $this->message[$pos]['parent'];
 372                                 if($this->message[$parent]['type'] != 'map'){
 373                                         if(strtolower($this->message[$parent]['type']) == 'array'){
 374                                                 $this->message[$parent]['result'][] = $this->message[$pos]['result'];
 375                                         } else {
 376                                                 $this->message[$parent]['result'][$this->message[$pos]['name']] = $this->message[$pos]['result'];
 377                                         }
 378                                 }
 379                                 */
 380                         }
 381                 }
 382
 383         // for doclit
 384         if($this->status == 'header'){
 385                 if ($this->root_header != $pos) {
 386                         $this->responseHeaders .= "</" . (isset($prefix) ? $prefix . ':' : '') . "$name>";
 387                 }
 388         } elseif($pos >= $this->root_struct){
 389                 $this->document .= "</" . (isset($prefix) ? $prefix . ':' : '') . "$name>";
 390         }
 391                 // switch status
 392                 if ($pos == $this->root_struct){
 393                         $this->status = 'body';
 394                         $this->root_struct_namespace = $this->message[$pos]['namespace'];
 395                 } elseif ($pos == $this->root_header) {
 396                         $this->status = 'envelope';
 397                 } elseif ($name == 'Body' && $this->status == 'body') {
 398                         $this->status = 'envelope';
 399                 } elseif ($name == 'Header' && $this->status == 'header') { // will never happen
 400                         $this->status = 'envelope';
 401                 } elseif ($name == 'Envelope' && $this->status == 'envelope') {
 402                         $this->status = '';
 403                 }
 404                 // set parent back to my parent
 405                 $this->parent = $this->message[$pos]['parent'];
 406         }
 407
 408         /**
 409         * element content handler
 410         *
 411         * @param    resource $parser XML parser object
 412         * @param    string $data element content
 413         * @access   private
 414         */
 415         function character_data($parser, $data){
 416                 $pos = $this->depth_array[$this->depth];
 417                 if ($this->xml_encoding=='UTF-8'){
 418                         // TODO: add an option to disable this for folks who want
 419                         // raw UTF-8 that, e.g., might not map to iso-8859-1
 420                         // TODO: this can also be handled with xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, "ISO-8859-1");
 421                         if($this->decode_utf8){
 422                                 $data = utf8_decode($data);
 423                         }
 424                 }
 425         $this->message[$pos]['cdata'] .= $data;
 426         // for doclit
 427         if($this->status == 'header'){
 428                 $this->responseHeaders .= $data;
 429         } else {
 430                 $this->document .= $data;
 431         }
 432         }
 433
 434         /**
 435         * get the parsed message (SOAP Body)
 436         *
 437         * @return       mixed
 438         * @access   public
 439         * @deprecated   use get_soapbody instead
 440         */
 441         function get_response(){
 442                 return $this->soapresponse;
 443         }
 444
 445         /**
 446         * get the parsed SOAP Body (NULL if there was none)
 447         *
 448         * @return       mixed
 449         * @access   public
 450         */
 451         function get_soapbody(){
 452                 return $this->soapresponse;
 453         }
 454
 455         /**
 456         * get the parsed SOAP Header (NULL if there was none)
 457         *
 458         * @return       mixed
 459         * @access   public
 460         */
 461         function get_soapheader(){
 462                 return $this->soapheader;
 463         }
 464
 465         /**
 466         * get the unparsed SOAP Header
 467         *
 468         * @return       string XML or empty if no Header
 469         * @access   public
 470         */
 471         function getHeaders(){
 472             return $this->responseHeaders;
 473         }
 474
 475         /**
 476         * decodes simple types into PHP variables
 477         *
 478         * @param    string $value value to decode
 479         * @param    string $type XML type to decode
 480         * @param    string $typens XML type namespace to decode
 481         * @return       mixed PHP value
 482         * @access   private
 483         */
 484         function decodeSimple($value, $type, $typens) {
 485                 // TODO: use the namespace!
 486                 if ((!isset($type)) || $type == 'string' || $type == 'long' || $type == 'unsignedLong') {
 487                         return (string) $value;
 488                 }
 489                 if ($type == 'int' || $type == 'integer' || $type == 'short' || $type == 'byte') {
 490                         return (int) $value;
 491                 }
 492                 if ($type == 'float' || $type == 'double' || $type == 'decimal') {
 493                         return (double) $value;
 494                 }
 495                 if ($type == 'boolean') {
 496                         if (strtolower($value) == 'false' || strtolower($value) == 'f') {
 497                                 return false;
 498                         }
 499                         return (boolean) $value;
 500                 }
 501                 if ($type == 'base64' || $type == 'base64Binary') {
 502                         $this->debug('Decode base64 value');
 503                         return base64_decode($value);
 504                 }
 505                 // obscure numeric types
 506                 if ($type == 'nonPositiveInteger' || $type == 'negativeInteger'
 507                         || $type == 'nonNegativeInteger' || $type == 'positiveInteger'
 508                         || $type == 'unsignedInt'
 509                         || $type == 'unsignedShort' || $type == 'unsignedByte') {
 510                         return (int) $value;
 511                 }
 512                 // bogus: parser treats array with no elements as a simple type
 513                 if ($type == 'array') {
 514                         return array();
 515                 }
 516                 // everything else
 517                 return (string) $value;
 518         }
 519
 520         /**
 521         * builds response structures for compound values (arrays/structs)
 522         * and scalars
 523         *
 524         * @param    integer $pos position in node tree
 525         * @return       mixed   PHP value
 526         * @access   private
 527         */
 528         function buildVal($pos){
 529                 if(!isset($this->message[$pos]['type'])){
 530                         $this->message[$pos]['type'] = '';
 531                 }
 532                 $this->debug('in buildVal() for '.$this->message[$pos]['name']."(pos $pos) of type ".$this->message[$pos]['type']);
 533                 // if there are children...
 534                 if($this->message[$pos]['children'] != ''){
 535                         $this->debug('in buildVal, there are children');
 536                         $children = explode('|',$this->message[$pos]['children']);
 537                         array_shift($children); // knock off empty
 538                         // md array
 539                         if(isset($this->message[$pos]['arrayCols']) && $this->message[$pos]['arrayCols'] != ''){
 540                 $r=0; // rowcount
 541                 $c=0; // colcount
 542                 foreach($children as $child_pos){
 543                                         $this->debug("in buildVal, got an MD array element: $r, $c");
 544                                         $params[$r][] = $this->message[$child_pos]['result'];
 545                                     $c++;
 546                                     if($c == $this->message[$pos]['arrayCols']){
 547                                         $c = 0;
 548                                                 $r++;
 549                                     }
 550                 }
 551             // array
 552                         } elseif($this->message[$pos]['type'] == 'array' || $this->message[$pos]['type'] == 'Array'){
 553                 $this->debug('in buildVal, adding array '.$this->message[$pos]['name']);
 554                 foreach($children as $child_pos){
 555                         $params[] = &$this->message[$child_pos]['result'];
 556                 }
 557             // apache Map type: java hashtable
 558             } elseif($this->message[$pos]['type'] == 'Map' && $this->message[$pos]['type_namespace'] == 'http://xml.apache.org/xml-soap'){
 559                 $this->debug('in buildVal, Java Map '.$this->message[$pos]['name']);
 560                 foreach($children as $child_pos){
 561                         $kv = explode("|",$this->message[$child_pos]['children']);
 562                         $params[$this->message[$kv[1]]['result']] = &$this->message[$kv[2]]['result'];
 563                 }
 564             // generic compound type
 565             //} elseif($this->message[$pos]['type'] == 'SOAPStruct' || $this->message[$pos]['type'] == 'struct') {
 566                     } else {
 567                         // Apache Vector type: treat as an array
 568                 $this->debug('in buildVal, adding Java Vector or generic compound type '.$this->message[$pos]['name']);
 569                                 if ($this->message[$pos]['type'] == 'Vector' && $this->message[$pos]['type_namespace'] == 'http://xml.apache.org/xml-soap') {
 570                                         $notstruct = 1;
 571                                 } else {
 572                                         $notstruct = 0;
 573                     }
 574                 //
 575                 foreach($children as $child_pos){
 576                         if($notstruct){
 577                                 $params[] = &$this->message[$child_pos]['result'];
 578                         } else {
 579                                 if (isset($params[$this->message[$child_pos]['name']])) {
 580                                         // de-serialize repeated element name into an array
 581                                         if ((!is_array($params[$this->message[$child_pos]['name']])) || (!isset($params[$this->message[$child_pos]['name']][0]))) {
 582                                                 $params[$this->message[$child_pos]['name']] = array($params[$this->message[$child_pos]['name']]);
 583                                         }
 584                                         $params[$this->message[$child_pos]['name']][] = &$this->message[$child_pos]['result'];
 585                                 } else {
 586                                                 $params[$this->message[$child_pos]['name']] = &$this->message[$child_pos]['result'];
 587                                             }
 588                         }
 589                 }
 590                         }
 591                         if (isset($this->message[$pos]['xattrs'])) {
 592                 $this->debug('in buildVal, handling attributes');
 593                                 foreach ($this->message[$pos]['xattrs'] as $n => $v) {
 594                                         $params[$n] = $v;
 595                                 }
 596                         }
 597                         // handle simpleContent
 598                         if (isset($this->message[$pos]['cdata']) && trim($this->message[$pos]['cdata']) != '') {
 599                 $this->debug('in buildVal, handling simpleContent');
 600                 if (isset($this->message[$pos]['type'])) {
 601                                         $params['!'] = $this->decodeSimple($this->message[$pos]['cdata'], $this->message[$pos]['type'], isset($this->message[$pos]['type_namespace']) ? $this->message[$pos]['type_namespace'] : '');
 602                                 } else {
 603                                         $parent = $this->message[$pos]['parent'];
 604                                         if (isset($this->message[$parent]['type']) && ($this->message[$parent]['type'] == 'array') && isset($this->message[$parent]['arrayType'])) {
 605                                                 $params['!'] = $this->decodeSimple($this->message[$pos]['cdata'], $this->message[$parent]['arrayType'], isset($this->message[$parent]['arrayTypeNamespace']) ? $this->message[$parent]['arrayTypeNamespace'] : '');
 606                                         } else {
 607                                                 $params['!'] = $this->message[$pos]['cdata'];
 608                                         }
 609                                 }
 610                         }
 611                         $ret = is_array($params) ? $params : array();
 612                         $this->debug('in buildVal, return:');
 613                         $this->appendDebug($this->varDump($ret));
 614                         return $ret;
 615                 } else {
 616                 $this->debug('in buildVal, no children, building scalar');
 617                         $cdata = isset($this->message[$pos]['cdata']) ? $this->message[$pos]['cdata'] : '';
 618                 if (isset($this->message[$pos]['type'])) {
 619                                 $ret = $this->decodeSimple($cdata, $this->message[$pos]['type'], isset($this->message[$pos]['type_namespace']) ? $this->message[$pos]['type_namespace'] : '');
 620                                 $this->debug("in buildVal, return: $ret");
 621                                 return $ret;
 622                         }
 623                         $parent = $this->message[$pos]['parent'];
 624                         if (isset($this->message[$parent]['type']) && ($this->message[$parent]['type'] == 'array') && isset($this->message[$parent]['arrayType'])) {
 625                                 $ret = $this->decodeSimple($cdata, $this->message[$parent]['arrayType'], isset($this->message[$parent]['arrayTypeNamespace']) ? $this->message[$parent]['arrayTypeNamespace'] : '');
 626                                 $this->debug("in buildVal, return: $ret");
 627                                 return $ret;
 628                         }
 629                 $ret = $this->message[$pos]['cdata'];
 630                         $this->debug("in buildVal, return: $ret");
 631                 return $ret;
 632                 }
 633         }
 634 }
 635
 636 /**
 637  * Backward compatibility
 638  */
 639 class soap_parser extends nusoap_parser {
 640 }
 641
 642
 643 ?>